From c341b71994f874a0142deda06917bafe4a900fa1 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Fri, 22 May 2026 23:57:52 +0000 Subject: [PATCH 01/12] descriptor: reflect view containers via ReflectList/ReflectMap MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add the runtime half of vtable-mode reflection: ReflectList/ReflectMap impls for the zero-copy view containers RepeatedView and MapView, so a generated view's reflective get() can return a borrowed list/map without materializing a Vec. Introduce two helper traits, ReflectElement and ReflectMapKey, with concrete impls for scalars, &str, &[u8], and EnumValue. A trait-bound blanket over ReflectMessage is not possible — it would overlap the scalar impls under Rust's coherence rules — so codegen will emit a one-line ReflectElement impl per generated view and enum in a later change. Map reflection deduplicates duplicate wire entries (last-write-wins) via MapView::iter_unique to match the bridge path's distinct-key semantics, keeping len() and for_each() consistent across both reflection modes. Also record the landed ValueRef::List/Map refactor and the coherence constraint in the vtable design doc. --- buffa-descriptor/src/lib.rs | 5 +- buffa-descriptor/src/reflect/mod.rs | 2 + buffa-descriptor/src/reflect/value.rs | 14 +- buffa-descriptor/src/reflect/view.rs | 349 +++++++++++++++++++++++ docs/investigations/reflection-vtable.md | 290 ++++++++++++------- 5 files changed, 547 insertions(+), 113 deletions(-) create mode 100644 buffa-descriptor/src/reflect/view.rs diff --git a/buffa-descriptor/src/lib.rs b/buffa-descriptor/src/lib.rs index 96cf152..43c8069 100644 --- a/buffa-descriptor/src/lib.rs +++ b/buffa-descriptor/src/lib.rs @@ -49,6 +49,7 @@ pub use pool::{DescriptorPool, PoolError}; pub use reflect::DynamicMessageSeed; #[cfg(feature = "reflect")] pub use reflect::{ - AnyError, DynamicMessage, MapKey, MapKeyRef, MapValue, ReflectCow, ReflectList, ReflectMap, - ReflectMessage, ReflectMessageMut, ReflectMode, Reflectable, Value, ValueRef, + AnyError, DynamicMessage, MapKey, MapKeyRef, MapValue, ReflectCow, ReflectElement, ReflectList, + ReflectMap, ReflectMapKey, ReflectMessage, ReflectMessageMut, ReflectMode, Reflectable, Value, + ValueRef, }; diff --git a/buffa-descriptor/src/reflect/mod.rs b/buffa-descriptor/src/reflect/mod.rs index b6a4ae5..5cf04da 100644 --- a/buffa-descriptor/src/reflect/mod.rs +++ b/buffa-descriptor/src/reflect/mod.rs @@ -27,12 +27,14 @@ mod dynamic; mod json; mod message; mod value; +mod view; pub use dynamic::{AnyError, DynamicMessage}; #[cfg(feature = "json")] pub use json::DynamicMessageSeed; pub use message::{ReflectCow, ReflectMessage, ReflectMessageMut, Reflectable}; pub use value::{MapKey, MapKeyRef, MapValue, ReflectList, ReflectMap, Value, ValueRef}; +pub use view::{ReflectElement, ReflectMapKey}; /// Per-message reflection mode, selected at codegen time. /// diff --git a/buffa-descriptor/src/reflect/value.rs b/buffa-descriptor/src/reflect/value.rs index 080ec0a..69c8ecf 100644 --- a/buffa-descriptor/src/reflect/value.rs +++ b/buffa-descriptor/src/reflect/value.rs @@ -169,10 +169,10 @@ impl<'a> ValueRef<'a> { /// A reflective view over a repeated field's elements. /// -/// `DynamicMessage` (bridge mode) implements this for `[Value]`. Vtable-mode -/// generated `impl ReflectMessage for FooView<'a>` (deferred — see the -/// reflection design doc) will implement it per element type so a repeated -/// field can be read without materializing a `Vec`. +/// `DynamicMessage` (bridge mode) implements this for `Vec`. Vtable mode +/// implements it generically for [`RepeatedView`](buffa::RepeatedView) over any +/// [`ReflectElement`](super::ReflectElement), so a repeated field can be read +/// without materializing a `Vec`. /// /// `for_each` is the dyn-safe non-allocating iteration form, mirroring /// [`ReflectMessage::for_each_set`]. There is no `iter()` because trait @@ -197,8 +197,10 @@ pub trait ReflectList: core::fmt::Debug { /// A reflective view over a map field's entries. /// -/// `DynamicMessage` (bridge mode) implements this for [`MapValue`]. Vtable -/// mode (deferred) will implement it for `MapView<'a, K, V>`. +/// `DynamicMessage` (bridge mode) implements this for [`MapValue`]. Vtable mode +/// implements it generically for [`MapView`](buffa::MapView), deduplicating +/// duplicate wire entries to distinct keys so both modes present the same +/// logical map. /// /// Iteration order is unspecified — callers must not depend on it. The /// bridge-mode `MapValue` happens to iterate in `MapKey`-sorted order; vtable diff --git a/buffa-descriptor/src/reflect/view.rs b/buffa-descriptor/src/reflect/view.rs new file mode 100644 index 0000000..2855b7b --- /dev/null +++ b/buffa-descriptor/src/reflect/view.rs @@ -0,0 +1,349 @@ +//! Reflective container access over zero-copy [view types](buffa::view). +//! +//! This module bridges the reflection value model ([`ValueRef`], +//! [`ReflectList`], [`ReflectMap`]) to the view containers +//! [`RepeatedView`](buffa::RepeatedView) and [`MapView`](buffa::MapView), so a +//! vtable-mode `impl ReflectMessage for FooView<'a>` can return +//! `ValueRef::List(&self.tags)` / `ValueRef::Map(&self.labels)` without +//! materializing a `Vec` or `MapValue`. The bridge path +//! ([`DynamicMessage`](super::DynamicMessage)) implements the same +//! [`ReflectList`] / [`ReflectMap`] traits for `Vec` / `MapValue` (see +//! `value.rs`); these impls are the vtable counterpart. +//! +//! ## Why a per-element helper trait, and why it is not a blanket +//! +//! The container impls are fully generic over the element type via +//! [`ReflectElement`] (and [`ReflectMapKey`] for map keys). The tempting shape +//! is a single blanket `impl ReflectElement for M` that lets +//! repeated-of-message fall out for free. Rust rejects it (E0119): a +//! trait-bound blanket overlaps with every concrete impl — `impl ReflectElement +//! for i32` included — because the compiler cannot prove `i32: !ReflectMessage`. +//! So the closed set of element types (scalars, `&str`, `&[u8]`, +//! [`EnumValue`](buffa::EnumValue)) gets concrete impls here, and the +//! open-ended cases — message views and bare closed enums — get a one-line +//! `impl ReflectElement` emitted by codegen (a foreign-trait-for-local-type +//! impl, which the orphan rule permits in the consumer crate). That impl is per +//! *type*, not per *field*: a message used in ten repeated fields gets one impl. +//! +//! See `docs/investigations/reflection-vtable.md` §3 for the full rationale. + +use buffa::{EnumValue, Enumeration, MapView, RepeatedView}; + +use super::value::{MapKey, MapKeyRef, ReflectList, ReflectMap, ValueRef}; + +/// Conversion of a single repeated-field element (or map value) to a borrowed +/// [`ValueRef`]. +/// +/// Implemented here for the closed set of view element types (scalars, `&str`, +/// `&[u8]`, [`EnumValue`]). Codegen emits a one-line impl for each generated +/// message view type (yielding [`ValueRef::Message`]) and each bare closed +/// enum (yielding [`ValueRef::EnumNumber`]) — these cannot be covered by a +/// blanket impl without colliding with the scalar impls under Rust's coherence +/// rules. +/// +/// A hand-written or codegen-emitted implementer must also derive [`Debug`]: +/// the [`core::fmt::Debug`] supertrait is what lets the generic [`ReflectList`] +/// / [`ReflectMap`] impls below satisfy *their* own `Debug` supertrait through +/// the `RepeatedView: Debug` / `MapView: Debug` derives. +pub trait ReflectElement: core::fmt::Debug { + /// Borrow this element as a [`ValueRef`]. + #[must_use] + fn as_value_ref(&self) -> ValueRef<'_>; +} + +/// Conversion of a single map key to a borrowed [`MapKeyRef`]. +/// +/// Implemented for the spec-valid protobuf map-key types: the integral types, +/// `bool`, and `&str`. The `&[u8]` impl exists only for the editions +/// `utf8_validation = NONE` edge case, where a `string` map key is typed as +/// bytes in the view; it converts via UTF-8 and is documented as best-effort +/// (see the impl). +/// +/// The [`PartialEq`] supertrait is required so the generic [`ReflectMap`] impl +/// can deduplicate wire entries via [`MapView::iter_unique`](buffa::MapView::iter_unique), +/// matching the bridge path's distinct-key semantics. The [`Debug`] supertrait +/// plays the same role as it does for [`ReflectElement`]. +pub trait ReflectMapKey: core::fmt::Debug + PartialEq { + /// Borrow this key as a [`MapKeyRef`]. + #[must_use] + fn as_map_key_ref(&self) -> MapKeyRef<'_>; +} + +// ── Element impls (closed set) ────────────────────────────────────────────── + +macro_rules! impl_scalar_element { + ($($t:ty => $variant:ident),* $(,)?) => {$( + impl ReflectElement for $t { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::$variant(*self) + } + } + )*}; +} + +impl_scalar_element! { + i32 => I32, + i64 => I64, + u32 => U32, + u64 => U64, + bool => Bool, + f32 => F32, + f64 => F64, +} + +impl ReflectElement for &str { + fn as_value_ref(&self) -> ValueRef<'_> { + // `self` (a `&&str`) auto-derefs to the inner `&str`; an explicit + // `*self` would trip `clippy::explicit_auto_deref`. + ValueRef::String(self) + } +} + +impl ReflectElement for &[u8] { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::Bytes(self) + } +} + +impl ReflectElement for EnumValue { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::EnumNumber(self.to_i32()) + } +} + +// ── Map key impls (spec-valid key set) ────────────────────────────────────── + +macro_rules! impl_scalar_key { + ($($t:ty => $variant:ident),* $(,)?) => {$( + impl ReflectMapKey for $t { + fn as_map_key_ref(&self) -> MapKeyRef<'_> { + MapKeyRef::$variant(*self) + } + } + )*}; +} + +impl_scalar_key! { + i32 => I32, + i64 => I64, + u32 => U32, + u64 => U64, + bool => Bool, +} + +impl ReflectMapKey for &str { + fn as_map_key_ref(&self) -> MapKeyRef<'_> { + MapKeyRef::String(self) + } +} + +impl ReflectMapKey for &[u8] { + fn as_map_key_ref(&self) -> MapKeyRef<'_> { + // Reached only for a `string` map key with editions + // `utf8_validation = NONE`, which the view types as `&[u8]`. The proto + // type is `string`, so the bytes are normally valid UTF-8; this is a + // best-effort conversion, not a hard error. + // + // Known limitation: the reflection key model ([`MapKey`] / [`MapKeyRef`]) + // represents string keys as UTF-8, with no bytes variant (bytes are not + // a spec-valid map key). The bridge path shares this constraint — it + // also stores string keys as `String`. Non-UTF-8 keys therefore collapse + // to `""`, which can collide with a genuine empty-string key. This is + // accepted because the case is exotic (a `string` field is normally + // UTF-8) and faithful representation is not possible without widening + // the spec-valid key set. + MapKeyRef::String(core::str::from_utf8(self).unwrap_or("")) + } +} + +// ── Container impls ───────────────────────────────────────────────────────── + +impl ReflectList for RepeatedView<'_, T> { + fn len(&self) -> usize { + let elements: &[T] = self; + elements.len() + } + + fn get(&self, idx: usize) -> Option> { + let elements: &[T] = self; + elements.get(idx).map(ReflectElement::as_value_ref) + } + + fn for_each(&self, f: &mut dyn FnMut(ValueRef<'_>)) { + for elem in self.iter() { + f(elem.as_value_ref()); + } + } +} + +impl ReflectMap for MapView<'_, K, V> { + fn len(&self) -> usize { + // Distinct-key count, matching the bridge path (`MapValue` dedups at + // construction). `MapView` preserves duplicate wire entries, so a raw + // `iter().count()` would over-count and diverge from `MapValue::len`. + self.len_unique() + } + + fn get(&self, key: &MapKey) -> Option> { + // Reverse scan finds the last occurrence first — last-write-wins, + // matching protobuf map decode semantics and the documented `O(n)` + // `MapView` lookup. A consumer needing `O(1)` collects into a `HashMap`. + let want = key.as_ref(); + self.iter() + .rev() + .find(|(k, _)| k.as_map_key_ref() == want) + .map(|(_, v)| v.as_value_ref()) + } + + fn get_str(&self, key: &str) -> Option> { + self.iter() + .rev() + .find(|(k, _)| matches!(k.as_map_key_ref(), MapKeyRef::String(s) if s == key)) + .map(|(_, v)| v.as_value_ref()) + } + + fn for_each(&self, f: &mut dyn FnMut(MapKeyRef<'_>, ValueRef<'_>)) { + // Dedup to distinct keys (last-write-wins), matching the bridge path so + // both reflection modes visit each logical entry exactly once. + for (k, v) in self.iter_unique() { + f(k.as_map_key_ref(), v.as_value_ref()); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use alloc::string::ToString; + use alloc::vec; + use alloc::vec::Vec; + + #[test] + fn repeated_scalar_list() { + let view: RepeatedView<'_, i32> = RepeatedView::new(vec![7, 11, 13]); + let list: &dyn ReflectList = &view; + assert_eq!(list.len(), 3); + assert!(!list.is_empty()); + assert!(matches!(list.get(1), Some(ValueRef::I32(11)))); + assert!(list.get(3).is_none()); + + let mut sum = 0; + list.for_each(&mut |v| { + if let ValueRef::I32(n) = v { + sum += n; + } + }); + assert_eq!(sum, 31); + } + + #[test] + fn repeated_string_list_is_borrowed() { + let view: RepeatedView<'_, &str> = RepeatedView::new(vec!["a", "b"]); + let list: &dyn ReflectList = &view; + assert_eq!(list.len(), 2); + assert!(matches!(list.get(0), Some(ValueRef::String("a")))); + assert!(matches!(list.get(1), Some(ValueRef::String("b")))); + } + + #[test] + fn repeated_bytes_list() { + let a: &[u8] = &[0xDE, 0xAD]; + let b: &[u8] = &[0xBE, 0xEF]; + let view: RepeatedView<'_, &[u8]> = RepeatedView::new(vec![a, b]); + let list: &dyn ReflectList = &view; + match list.get(0) { + Some(ValueRef::Bytes(bytes)) => assert_eq!(bytes, &[0xDE, 0xAD]), + other => panic!("expected Bytes, got {other:?}"), + } + } + + #[test] + fn empty_list() { + let view: RepeatedView<'_, i32> = RepeatedView::default(); + let list: &dyn ReflectList = &view; + assert_eq!(list.len(), 0); + assert!(list.is_empty()); + assert!(list.get(0).is_none()); + } + + #[test] + fn map_string_keyed() { + let view: MapView<'_, &str, i32> = MapView::new(vec![("apples", 3), ("oranges", 7)]); + let map: &dyn ReflectMap = &view; + assert_eq!(map.len(), 2); + assert!(!map.is_empty()); + + // The no-alloc CEL hot path. + assert!(matches!(map.get_str("apples"), Some(ValueRef::I32(3)))); + assert!(matches!(map.get_str("oranges"), Some(ValueRef::I32(7)))); + assert!(map.get_str("durian").is_none()); + + // The descriptor-keyed path. + assert!(matches!( + map.get(&MapKey::String("apples".into())), + Some(ValueRef::I32(3)) + )); + assert!(map.get(&MapKey::String("missing".into())).is_none()); + + let mut total = 0; + map.for_each(&mut |_k, v| { + if let ValueRef::I32(n) = v { + total += n; + } + }); + assert_eq!(total, 10); + } + + #[test] + fn map_int_keyed_get_str_returns_none() { + let view: MapView<'_, i32, &str> = MapView::new(vec![(1, "one"), (2, "two")]); + let map: &dyn ReflectMap = &view; + // get_str on a non-string-keyed map yields None rather than matching. + assert!(map.get_str("1").is_none()); + assert!(matches!( + map.get(&MapKey::I32(2)), + Some(ValueRef::String("two")) + )); + } + + #[test] + fn map_last_write_wins_on_duplicate_keys() { + // MapView preserves wire order including duplicates; reflection + // resolves duplicates last-write-wins and presents distinct keys, + // matching the bridge path (`MapValue` dedups at construction). + let view: MapView<'_, &str, i32> = MapView::new(vec![("k", 1), ("k", 2)]); + let map: &dyn ReflectMap = &view; + assert!(matches!(map.get_str("k"), Some(ValueRef::I32(2)))); + assert!(matches!( + map.get(&MapKey::String("k".into())), + Some(ValueRef::I32(2)) + )); + // Distinct-key count and single visit, not the 2 raw wire entries. + assert_eq!(map.len(), 1); + let mut visits = Vec::new(); + map.for_each(&mut |_k, v| { + if let ValueRef::I32(n) = v { + visits.push(n); + } + }); + assert_eq!(visits, vec![2]); + } + + #[test] + fn map_bytes_keyed_utf8() { + // The `utf8_validation = NONE` edge case: a `string` map key typed as + // `&[u8]` in the view. Valid UTF-8 bytes reflect as a string key. + let apples: &[u8] = b"apples"; + let view: MapView<'_, &[u8], i32> = MapView::new(vec![(apples, 5)]); + let map: &dyn ReflectMap = &view; + assert_eq!(map.len(), 1); + assert!(matches!(map.get_str("apples"), Some(ValueRef::I32(5)))); + let mut keys = Vec::new(); + map.for_each(&mut |k, _v| { + if let MapKeyRef::String(s) = k { + keys.push(s.to_string()); + } + }); + assert_eq!(keys, vec!["apples".to_string()]); + } +} diff --git a/docs/investigations/reflection-vtable.md b/docs/investigations/reflection-vtable.md index 5306248..058dab4 100644 --- a/docs/investigations/reflection-vtable.md +++ b/docs/investigations/reflection-vtable.md @@ -1,11 +1,25 @@ # Vtable-mode `ReflectMessage` for message views -**Status:** Recommendation / pre-implementation analysis +**Status:** Pre-implementation analysis, partially landed **Builds on:** `reflect-prototype` branch (`docs/investigations/reflection-prototype-2026-05.md`) **Scope:** Generate `impl ReflectMessage` directly on view types (and optionally owned types), eliminating the bridge-mode encode → decode → `DynamicMessage` round-trip. This is the deferred `ReflectMode::VTable` deliverable. +## Progress + +- **2026-05-22** — Component 3 (the `ValueRef::List`/`Map` trait-object + refactor) has **landed.** This was flagged below as the only component with + real design risk and the reason vtable mode was deferred. `ValueRef` now + carries `List(&'a dyn ReflectList)` and `Map(&'a dyn ReflectMap)`, the + `ReflectList` / `ReflectMap` traits exist (with the no-alloc `get_str` CEL + path), `DynamicMessage` implements them for `Vec` / `MapValue`, and + conformance passes with the new shape. The API-breaking, conformance-gated + refactor that would have been painful to do after a release is therefore + behind us. Everything that remains is additive codegen and additive runtime + trait impls — no consumer-facing breaking change. See the revised §3 and the + revised sequencing for what this means for the remaining work. + ## Why Bridge mode (`ReflectMode::Bridge`, the only mode codegen currently emits) is: @@ -75,8 +89,10 @@ impl<'a> ::buffa_descriptor::reflect::ReflectMessage for FooView<'a> { .unwrap_or(WorkloadView::default_view_instance()), )), - // repeated/map — see component 3 (this is the open design decision) - 7 => /* ValueRef::List(...) — see §3 */, + // repeated/map — just borrow the view container; the blanket + // ReflectList/ReflectMap impls (§3) do the rest. No per-field codegen. + 7 => ValueRef::List(&self.tags), + 8 => ValueRef::Map(&self.labels), _ => { debug_assert!(false, "field {} not in {}", field.number(), Self::FULL_NAME); @@ -170,30 +186,15 @@ populated once when the pool is built. One lock instead of N, but adds a `HashMap` lookup per call. The per-message `OnceLock` is faster after warmup and keeps the per-message codegen self-contained. Prefer per-message. -### 3. `ValueRef::List` and `ValueRef::Map` — open design decision +### 3. `ValueRef::List` and `ValueRef::Map` — RESOLVED (landed) -**This is the reason vtable mode was deferred and the only component with -real design risk. It needs a decision before 0.7.0 ships.** +**This was the reason vtable mode was deferred and the only component with +real design risk. It has been resolved: option (a) below was adopted and has +landed.** The remaining text records the decision and the runtime that shipped, +and then specifies the *view-side* container impls that the vtable codegen +needs — which were not part of the landed change. -The current variants require materialized storage: - -```rust -pub enum ValueRef<'a> { - // ... - List(&'a [Value]), - Map(&'a MapValue), -} -``` - -`DynamicMessage` stores repeated/map fields as `Value::List(Vec)` and -`Value::Map(MapValue)` already, so it can return a slice/borrow. - -A view holds `RepeatedView<'a, T>` (a `Vec` where `T` is the per-element -view type — `&'a str`, `i32`, `BarView<'a>`, etc.) and `MapView<'a, K, V>`. -**There is no `&[Value]` to hand out.** A vtable `get()` would have to allocate -a `Vec` and find somewhere to store it so the borrow outlives the call. - -#### Option (a) — change to trait objects (recommended) +`ValueRef` now carries trait objects rather than materialized storage: ```rust pub enum ValueRef<'a> { @@ -202,77 +203,128 @@ pub enum ValueRef<'a> { Map(&'a dyn ReflectMap), } -pub trait ReflectList { +pub trait ReflectList: core::fmt::Debug { fn len(&self) -> usize; fn is_empty(&self) -> bool { self.len() == 0 } fn get(&self, idx: usize) -> Option>; fn for_each(&self, f: &mut dyn FnMut(ValueRef<'_>)); } -pub trait ReflectMap { +pub trait ReflectMap: core::fmt::Debug { fn len(&self) -> usize; fn is_empty(&self) -> bool { self.len() == 0 } fn get(&self, key: &MapKey) -> Option>; - /// Visit entries. Iteration order is unspecified — callers must not - /// depend on it (matches DynamicMessage and protobuf semantics). - fn for_each(&self, f: &mut dyn FnMut(ValueRef<'_>, ValueRef<'_>)); + fn get_str(&self, key: &str) -> Option>; // no-alloc CEL path + fn for_each(&self, f: &mut dyn FnMut(MapKeyRef<'_>, ValueRef<'_>)); } ``` -`Vec` and `MapValue` impl these trivially (`Value::as_ref()` already -exists). `RepeatedView<'a, T>` and `MapView<'a, K, V>` impl them per element -type — codegen emits these or a small set of generic impls covers the scalar -cases. This is structurally symmetric with the existing -`ReflectCow::Borrowed(&dyn ReflectMessage)` pattern, which is already accepted -in the design. - -Size: `&dyn ReflectList` is a 16-byte fat pointer. `&'a [Value]` is also 16 -bytes. `&'a MapValue` is 8 bytes → 16. `ValueRef`'s 32-byte budget assertion -still holds (largest variant remains `String`/`Bytes` at 16 + tag, or -`Message(ReflectCow)` at 16 + tag). +Bridge mode implements `ReflectList for Vec` and `ReflectMap for +MapValue`, so `DynamicMessage` returns a borrow with one extra vtable +indirection per element access. The `size_of::() <= 32` and +`size_of::() <= 24` assertions in `value.rs` still hold: a +`&dyn ReflectList` is a 16-byte fat pointer, the same width the old `&[Value]` +would have been. Conformance passes with this shape (the bridge tests in +`buffa-test/tests/reflect_bridge.rs` exercise `List`/`Map`/`get_str`). + +The two rejected alternatives are kept here for the record, because the +reasoning still constrains future changes: + +- **`OnceCell>` cache per repeated field on the view.** Materialize + on first access, cache, return the slice. Rejected: it grows the view struct + (a wire-format type) with one cell per repeated/map field, still allocates + once per field per view instance — defeating the field-mask use case — and + `OnceCell` is `!Sync`, which breaks `Send + Sync` `OwnedView`. +- **A separate `LazyValueRef` for vtable, `ValueRef` for bridge.** Rejected: + dual API surface forever, and it breaks the `ReflectMode` zero-diff promise + (a call site matching `ValueRef::List` would not handle `LazyValueRef::List`). + The `ReflectCow` design explicitly chose unified return types over parallel + APIs; this stays consistent with it. + +#### What still has to be built: container impls for the view types + +The landed change covers the *bridge* side (`Vec` / `MapValue`). The +vtable side needs `ReflectList` / `ReflectMap` implemented for the view +containers — `RepeatedView<'a, T>` and `MapView<'a, K, V>` — so a view's +`get()` can return `ValueRef::List(&self.tags)` directly. + +**One generic container impl per container; per-element conversion through a +helper trait.** The container impls are fully generic and live in +`buffa-descriptor` — because `ReflectList` / `ReflectMap` are local there and +the view containers (`RepeatedView` / `MapView`) are foreign from `buffa`, the +orphan rule permits an impl of the local trait for the foreign type with no +restriction. Codegen emits *zero* per-field container boilerplate — the +repeated/map arm of `get()` is just `ValueRef::List(&self.tags)`. -Cost: one virtual dispatch per element access. The conformance JSON serializer -and the WKT codecs iterate via `for_each_set` already — they switch from a -slice loop to a `for_each` callback. Mechanical. - -Break: this is a breaking change to `ValueRef`. The prototype is on a local -unpushed branch — there are zero released consumers. **Make the change before -`buffa-descriptor` 0.7.0 ships.** If 0.7.0 ships with `&[Value]` and vtable -mode lands in 0.8.0, this becomes a breaking `ValueRef` change with downstream -consumers, or a permanent parallel `LazyValueRef` API. Neither is good. - -#### Option (b) — `OnceCell>` cache per repeated field on the view - -Materialize on first access, cache, return the slice. Works without touching -`ValueRef`. Costs: - -- View struct grows by one `OnceCell>` per repeated/map field. -- `OnceCell` is `!Sync` — `OnceLock` would be needed for `Send + Sync` views, - which `OwnedView` requires. -- Repeated-field reflection still allocates, just once per field per view - instance. Defeats the point for field-mask consumers. -- Pollutes the view struct (a wire-format type) with reflection state. - -**Reject this option.** It optimizes for not changing `ValueRef` at the cost -of every other axis. - -#### Option (c) — separate `LazyValueRef` for vtable, keep `ValueRef` for bridge - -A second value type returned by a second trait method. Avoids the break, -costs: dual API surface forever, every reflection consumer needs two code -paths or an adapter, the `ReflectMode` zero-diff promise is broken (call -sites that handle `ValueRef::List(&[Value])` don't handle -`LazyValueRef::List(&dyn ReflectList)`). +```rust +// in buffa-descriptor. -**Reject this option.** The `ReflectCow` design explicitly chose unified -return types over parallel APIs (see the module doc in -`buffa-descriptor/src/reflect/message.rs`). Be consistent. +/// Per-element conversion to a borrowed reflective value. +pub trait ReflectElement: core::fmt::Debug { + fn as_value_ref(&self) -> ValueRef<'_>; +} +impl ReflectElement for i32 { /* I32 */ } // + i64/u32/u64/bool/f32/f64 +impl ReflectElement for &str { /* String */ } +impl ReflectElement for &[u8] { /* Bytes */ } +impl ReflectElement for EnumValue { /* EnumNumber(to_i32) */ } + +/// Per-key conversion (the spec-valid map-key types only). +pub trait ReflectMapKey: core::fmt::Debug { + fn as_map_key_ref(&self) -> MapKeyRef<'_>; +} +impl ReflectMapKey for i32 { /* I32 */ } // + i64/u32/u64/bool +impl ReflectMapKey for &str { /* String */ } -#### Decision needed +impl<'a, T: ReflectElement> ReflectList for RepeatedView<'a, T> { /* … */ } +impl<'a, K: ReflectMapKey, V: ReflectElement> ReflectMap for MapView<'a, K, V> { /* … */ } +``` -Adopt option (a). Land the `ValueRef::List`/`Map` change as its own commit -*ahead of* the vtable codegen, with conformance run before and after to prove -no regression. The vtable codegen then targets the new shape from the start. +**The message and enum element cases need a one-line codegen impl, not a +blanket — this is a coherence constraint, not a choice.** The tempting shape is +`impl ReflectElement for M`, letting repeated-of-message fall +out automatically. Rust rejects it (E0119): a trait-bound blanket +`impl ReflectElement for M` overlaps with every concrete +impl — `impl ReflectElement for i32` included — because the compiler cannot +prove `i32: !ReflectMessage` (nothing forbids `buffa-descriptor` from later +adding `impl ReflectMessage for i32`, and sealing does not factor into the +overlap check). The same argument kills `impl ReflectElement +for E` for bare (closed) enums. So: + +- **Scalars, `&str`, `&[u8]`, `EnumValue`** get concrete (or single-type- + constructor) impls in `buffa-descriptor`. `EnumValue` is fine because it is + a distinct type constructor, not a bare type parameter — it cannot overlap a + scalar. +- **Message views (`FooView<'a>`) and bare closed enums (`SomeEnum`)** get a + one-line `impl ReflectElement` emitted by codegen — an impl of a foreign + trait for a local type, which the orphan rule allows in the consumer crate. + This is per *type*, not per *field*: a message used in ten repeated fields + still gets one impl. The repeated-of-message and map-of-message cases the + original draft flagged for an early spike then resolve through that + per-type impl plus the generic container impl — no per-field codegen, but not + the zero-codegen the blanket would have given. + +Two further wrinkles to handle in the impls: + +1. **`get_str` on a generic `MapView`.** It cannot dispatch on `K` at the + type level, so `get_str` does a linear scan and matches + `MapKeyRef::String(_)` per entry, returning `None` for a non-string-keyed + map. This is acceptable: `MapView` lookup is already documented as `O(n)` + (the runtime comment calls this fine for the small maps protobuf produces), + so vtable maps match bridge maps in behavior, not in asymptotics. A consumer + that needs `O(1)` collects into a `HashMap`. +2. **`&[u8]` map keys (the exotic case).** A `string` map key with editions + `utf8_validation = NONE` is typed `&'a [u8]` in the view, but `MapKeyRef` + has no bytes variant (bytes are not a spec-valid map key). The proto type + *is* `string`, so the bytes are normally valid UTF-8; `ReflectMapKey for + &[u8]` converts via `from_utf8` and falls back to `""` on invalid input, + with a `debug_assert`. This keeps every generated map satisfiable by the + generic impl. Flagged as a low-severity correctness nuance, not a blocker. +3. **Coherence with the bridge impls.** The bridge `impl ReflectList for + Vec` does not collide with the view impls, because the view containers + are `RepeatedView` / `MapView`, not `Vec` / `MapValue`. This only becomes a + problem for **owned-message vtable** (component 6), where the owned repeated + field is a `Vec` — see that component for the resolution + (`impl ReflectElement for Value`, dropping the bespoke `Vec` impl). ### 4. `ReflectMode::VTable` plumbing @@ -308,17 +360,38 @@ will use. ## Sequencing -1. **`ValueRef::List`/`Map` change first, as its own commit.** Update - `DynamicMessage`, the JSON serde, the WKT codecs, the conformance runner. - Run conformance — must remain at 0 unexpected failures. This is a focused - refactor with a clear pass/fail gate. -2. **Per-message `MessageIndex` memoization.** Small, independent. -3. **`impl ReflectMessage for FooView<'a>` codegen.** The main deliverable. - Test against the existing `reflect_e2e.rs` tests by running them through - both bridge and vtable mode. -4. **`ReflectMode::VTable` wiring.** Once (3) is solid. -5. **`OwnedView` entry-point test.** Trivial once (3)–(4) land; do it as the - acceptance test. +Step 1 (`ValueRef::List`/`Map` trait objects) has landed — see the Progress +note. The remaining work, as a sequence of self-contained PRs each within the +≤250-net-line budget: + +1. ✅ **`ValueRef::List`/`Map` trait-object refactor.** Done. `ValueRef` carries + `&dyn ReflectList` / `&dyn ReflectMap`; `DynamicMessage` implements the + bridge side; conformance passes. +2. **Runtime container impls for the view types (§3).** `ReflectElement` / + `ReflectMapKey` traits plus blanket `ReflectList` / `ReflectMap` for + `RepeatedView` / `MapView`, in `buffa-descriptor`. Independent of codegen and + testable with hand-written views. Do this first — it de-risks the rest. +3. **`impl ReflectMessage for FooView<'a>` codegen + per-message `MessageIndex` + memoization (§1, §2).** The main deliverable, and the only high-risk PR. + Land it behind an internal mode flag so it merges without flipping any + default. Oneof dispatch and enum-number extraction are the tricky `get()` + arms. +4. **`ReflectMode::VTable` plumbing (§4).** `BuildConfig::reflect_mode`, the + `CodeGenConfig` field, `feature_gates`, the `protoc-gen-buffa` option, and + the vtable `Reflectable::reflect()` body (`ReflectCow::Borrowed(self)`). + Once (3) is solid. +5. **Acceptance: conformance via-vtable run + `OwnedView` entry-point test + (§5).** A `BUFFA_VIA_VTABLE` runner mode (decode_view → reflect → reflective + serialize), parallel to the existing `BUFFA_VIEW_JSON` / `BUFFA_VIA_REFLECT` + modes, plus the `OwnedView` → `&dyn ReflectMessage` test. Mostly test code; + a strong correctness gate. +6. **Owned-message vtable (optional follow-up).** `impl ReflectMessage` for the + owned struct, for the interceptor use case that holds an in-memory message + rather than wire bytes. Needs container impls for owned collections + (`Vec`), which forces the coherence resolution noted in §3: implement + `ReflectElement for Value` and drop the bespoke `impl ReflectList for + Vec`, unifying both paths. Scoped after views because views are the + zero-copy headline and owned vtable touches landed bridge code. ## What this does *not* solve @@ -337,17 +410,24 @@ later, which is the right call — don't gate downstream work on this. ## Risks -- **Conformance regression from the `ValueRef` refactor.** Mitigated by - landing it first with the conformance gate. -- **Codegen complexity for repeated-of-message and map-with-message-value.** - These need `ReflectList`/`ReflectMap` impls that yield - `ValueRef::Message(ReflectCow::Borrowed(&BarView))` per element. The - borrow lifetime ties to `&self` (the `RepeatedView`); covariance makes it - work but it's the most fiddly codegen case. Spike it early. -- **Oneof reflection.** Verify the `FooKindView<'a>` enum codegen exposes - the active variant in a way that the `get()` match can dispatch on. May - need a small accessor on the generated oneof enum. -- **Recursive message types.** `MessageFieldView` boxes precisely to - break recursion; verify `default_view_instance()` for a self-recursive - message doesn't recurse infinitely (it shouldn't — the default has no - set fields — but check). +- **Conformance regression from the `ValueRef` refactor.** Retired — the + refactor landed behind the conformance gate with no unexpected failures. +- **Repeated-of-message and map-with-message-value.** Downgraded from "most + fiddly codegen case, spike it early" to a non-issue for codegen: the blanket + `impl ReflectElement for M` (§3) handles them with no + per-field codegen. The residual risk is purely in the generic impls + themselves — the per-element borrow lifetime ties to `&self` (the + `RepeatedView`), and covariance makes it work. Cover it with a test in PR 2, + not a codegen spike. +- **Oneof reflection.** Verify the `FooKindView<'a>` enum codegen exposes the + active variant in a way the `get()` match can dispatch on. May need a small + accessor on the generated oneof view enum. This is now the sharpest remaining + codegen risk (PR 3). +- **Enum-number extraction.** Views store enum fields as + `buffa::EnumValue`, not a bare `i32`; `get()` must extract the wire number. + Confirm the `EnumValue` accessor and add the `ReflectElement for EnumValue` + impl in PR 2. +- **Recursive message types.** `MessageFieldView` boxes precisely to break + recursion; verify `default_view_instance()` for a self-recursive message does + not recurse infinitely (it should not — the default has no set fields — but + check). From 0aa8ed51953995cfcc40d11d1b5df268ea434003 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 00:09:16 +0000 Subject: [PATCH 02/12] codegen: emit vtable-mode ReflectMessage for view types MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Generate `impl ReflectMessage for FooView<'a>` directly on view types when both reflection and the internal vtable flag are set. get()/has() read view struct fields through a per-field match — no encode/decode round-trip and no DynamicMessage — covering scalars, string/bytes, enums, nested messages, repeated, map, optional presence, and oneof members. for_each_set walks the descriptor; to_dynamic falls back to a bridge-style snapshot. Also emit `impl ReflectElement` for view types and generated enums so a RepeatedView/MapView of messages or closed enums reflects through the generic container impls. Per-message MessageIndex is memoized via an inherent associated fn (collision-free across sibling views in a shared module). Gated behind a new internal CodeGenConfig flag, exposed experimentally as buffa_build::Config::generate_reflection_vtable. Bridge mode and the reflect() call-site contract are unchanged. --- buffa-build/src/lib.rs | 20 ++ buffa-codegen/src/enumeration.rs | 27 ++ buffa-codegen/src/lib.rs | 35 ++- buffa-codegen/src/reflect_view.rs | 356 ++++++++++++++++++++++++ buffa-codegen/src/tests/mod.rs | 1 + buffa-codegen/src/tests/reflect_view.rs | 101 +++++++ buffa-codegen/src/view.rs | 35 ++- buffa-test/build.rs | 9 +- buffa-test/tests/reflect_vtable.rs | 223 +++++++++++++++ 9 files changed, 801 insertions(+), 6 deletions(-) create mode 100644 buffa-codegen/src/reflect_view.rs create mode 100644 buffa-codegen/src/tests/reflect_view.rs create mode 100644 buffa-test/tests/reflect_vtable.rs diff --git a/buffa-build/src/lib.rs b/buffa-build/src/lib.rs index 72010b9..a8b1229 100644 --- a/buffa-build/src/lib.rs +++ b/buffa-build/src/lib.rs @@ -311,6 +311,26 @@ impl Config { self } + /// Additionally emit vtable-mode reflection (`impl ReflectMessage` on view + /// types) on top of the bridge-mode `Reflectable` impl. + /// + /// Requires [`generate_reflection`](Self::generate_reflection) and view + /// generation (both must be enabled — [`compile`](Self::compile) errors + /// otherwise). Vtable mode reads view struct fields directly through + /// `ReflectMessage`, with no encode/decode round-trip and no per-field + /// allocation for fields that are not read. + /// + /// **Experimental and `#[doc(hidden)]`.** This is a stopgap until the + /// public `ReflectMode` selector lands; the name and shape may change. It + /// is hidden from the rendered docs to avoid advertising an API that will + /// be superseded — internal builds use it directly. + #[doc(hidden)] + #[must_use] + pub fn generate_reflection_vtable(mut self, enabled: bool) -> Self { + self.codegen_config.generate_reflection_vtable = enabled; + self + } + /// Enable or disable unknown field preservation (default: true). /// /// When enabled (the default), unrecognized fields encountered during diff --git a/buffa-codegen/src/enumeration.rs b/buffa-codegen/src/enumeration.rs index df9af8d..34d1c9a 100644 --- a/buffa-codegen/src/enumeration.rs +++ b/buffa-codegen/src/enumeration.rs @@ -223,6 +223,31 @@ pub fn generate_enum( quote! {} }; + // Vtable-mode reflection: closed enums appear as bare `#name_ident` in + // `RepeatedView` / `MapView`, so they need a `ReflectElement` impl for the + // generic container impls to apply. Open enums use `EnumValue`, which + // `buffa-descriptor` already covers, so the impl is emitted only for closed + // enums — emitting it for open ones would just be dead `cargo doc` noise. + let reflect_element_impl = if ctx.config.generate_reflection + && ctx.config.generate_reflection_vtable + && crate::message::is_closed_enum(features) + { + crate::feature_gates::cfg_block( + quote! { + impl ::buffa_descriptor::reflect::ReflectElement for #name_ident { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::EnumNumber( + ::buffa::Enumeration::to_i32(self), + ) + } + } + }, + ctx.config.feature_gates().reflect, + ) + } else { + quote! {} + }; + let enum_doc = crate::comments::doc_attrs_resolved(ctx.comment(proto_fqn), proto_fqn, &ctx.type_map); let custom_type_attrs = crate::context::CodeGenContext::matching_attributes( @@ -280,5 +305,7 @@ pub fn generate_enum( &[#(Self::#value_idents),*] } } + + #reflect_element_impl }) } diff --git a/buffa-codegen/src/lib.rs b/buffa-codegen/src/lib.rs index c67a53d..9afc87f 100644 --- a/buffa-codegen/src/lib.rs +++ b/buffa-codegen/src/lib.rs @@ -36,6 +36,7 @@ pub(crate) mod imports; pub(crate) mod message; pub(crate) mod oneof; pub(crate) mod reflect; +pub(crate) mod reflect_view; pub(crate) mod view; use crate::generated::descriptor::FileDescriptorProto; @@ -459,10 +460,9 @@ pub struct CodeGenConfig { /// /// **Performance** — `reflect()` is one full encode/decode round-trip /// plus a heap allocation. The first call also pays a one-time pool - /// build cost (linking the embedded `FileDescriptorSet`). The vtable - /// mode (zero-copy reflective access) is a deferred follow-up; the - /// call-site contract is the same either way, so flipping modes later - /// requires no consumer-code diff. + /// build cost (linking the embedded `FileDescriptorSet`). For zero-copy + /// reflective access over view types without the round-trip, additionally + /// enable [`generate_reflection_vtable`](Self::generate_reflection_vtable). /// /// **Binary size** — each package embeds its own copy of the full /// `FileDescriptorSet` (transitive closure). For a multi-package @@ -472,6 +472,18 @@ pub struct CodeGenConfig { /// /// Defaults to `false`. pub generate_reflection: bool, + /// Additionally emit `impl ReflectMessage` / `impl ReflectElement` on view + /// types (vtable mode), on top of the bridge-mode `Reflectable` impl. + /// + /// Requires [`generate_reflection`](Self::generate_reflection) (the vtable + /// impls resolve against the same embedded `DescriptorPool`) and + /// [`generate_views`](Self::generate_views). Internal flag, not yet exposed + /// through `buffa-build`; the public `ReflectMode` surface is wired + /// separately. Vtable mode reads view struct fields directly — no + /// encode/decode round-trip and no per-field allocation. + /// + /// Defaults to `false`. + pub generate_reflection_vtable: bool, } impl Default for CodeGenConfig { @@ -496,6 +508,7 @@ impl Default for CodeGenConfig { gate_impls_on_crate_features: false, generate_with_setters: true, generate_reflection: false, + generate_reflection_vtable: false, } } } @@ -648,6 +661,20 @@ pub fn generate( files_to_generate: &[String], config: &CodeGenConfig, ) -> Result, CodeGenError> { + // Vtable reflection emits `impl ReflectMessage` on view types and resolves + // against the per-package descriptor pool, so it needs both view generation + // and bridge-mode reflection (which emits that pool). Without this check the + // flag would silently emit nothing and the consumer would hit an opaque + // "FooView: ReflectMessage is not satisfied" error far from the cause. + if config.generate_reflection_vtable && (!config.generate_reflection || !config.generate_views) + { + return Err(CodeGenError::Other( + "generate_reflection_vtable requires both generate_reflection and \ + generate_views to be enabled" + .into(), + )); + } + let ctx = context::CodeGenContext::for_generate(file_descriptors, files_to_generate, config); // Group requested files by package. BTreeMap → deterministic output order. diff --git a/buffa-codegen/src/reflect_view.rs b/buffa-codegen/src/reflect_view.rs new file mode 100644 index 0000000..e07f0dc --- /dev/null +++ b/buffa-codegen/src/reflect_view.rs @@ -0,0 +1,356 @@ +//! Code generation for vtable-mode reflection on view types. +//! +//! When [`CodeGenConfig::generate_reflection`](crate::CodeGenConfig::generate_reflection) +//! and the internal `generate_reflection_vtable` flag are both set, each +//! generated view type gets: +//! +//! - `impl ::buffa_descriptor::reflect::ReflectMessage for FooView<'a>` — a +//! zero-copy reflective accessor that reads struct fields directly, with no +//! encode/decode round-trip and no `DynamicMessage`. +//! - `impl ::buffa_descriptor::reflect::ReflectElement for FooView<'a>` — so a +//! `RepeatedView`/`MapView` of this message reflects through the generic +//! container impls in `buffa-descriptor` (see that crate's `reflect::view`). +//! - A memoized per-message `MessageIndex` accessor. +//! +//! The bridge-mode `Reflectable` impl (on the owned message) is emitted +//! separately by [`reflect`](crate::reflect) and is unaffected; the +//! `Reflectable::reflect()` body switch to borrow the view directly is wired in +//! a later change. This module only adds the `ReflectMessage` surface. + +use std::collections::HashMap; + +use proc_macro2::TokenStream; +use quote::quote; + +use crate::context::{MessageScope, SENTINEL_MOD}; +use crate::features::resolve_field; +use crate::generated::descriptor::field_descriptor_proto::{Label, Type}; +use crate::generated::descriptor::DescriptorProto; +use crate::idents::make_field_ident; +use crate::impl_message::{ + effective_type, is_explicit_presence_scalar, is_real_oneof_member, is_supported_field_type, +}; +use crate::message::{is_closed_enum, is_map_field}; +use crate::oneof::oneof_variant_ident; +use crate::view::resolve_view_ty_tokens; +use crate::CodeGenError; + +/// The `ValueRef` scalar variant for a wire-numeric proto type. +/// +/// Mirrors the wire form, matching `DynamicMessage`: `int32`/`sint32`/`sfixed32` +/// all map to `I32`, etc. String, bytes, enum, and message types are handled by +/// the callers, not here. +fn scalar_variant(ty: Type) -> TokenStream { + match ty { + Type::TYPE_INT32 | Type::TYPE_SINT32 | Type::TYPE_SFIXED32 => quote! { I32 }, + Type::TYPE_INT64 | Type::TYPE_SINT64 | Type::TYPE_SFIXED64 => quote! { I64 }, + Type::TYPE_UINT32 | Type::TYPE_FIXED32 => quote! { U32 }, + Type::TYPE_UINT64 | Type::TYPE_FIXED64 => quote! { U64 }, + Type::TYPE_BOOL => quote! { Bool }, + Type::TYPE_FLOAT => quote! { F32 }, + Type::TYPE_DOUBLE => quote! { F64 }, + // Non-scalar types never reach this helper. + _ => quote! { Bool }, + } +} + +/// The default literal for a wire-numeric proto type (`0`, `0.0`, or `false`). +fn scalar_default(ty: Type) -> TokenStream { + match ty { + Type::TYPE_BOOL => quote! { false }, + Type::TYPE_FLOAT | Type::TYPE_DOUBLE => quote! { 0.0 }, + _ => quote! { 0 }, + } +} + +/// Generate the vtable reflection impls for a single view type. +/// +/// `view_scope` is the view struct's scope (`nesting + 2` below the package +/// root). `view_depth` is that same depth, used to climb back to the package +/// root for the `__buffa::reflect::descriptor_pool()` accessor. `oneof_idents` +/// and `view_oneof_prefix` come from the view-struct generation so oneof +/// members dispatch through the same view-oneof enum. +pub(crate) fn reflect_view_impls( + view_scope: MessageScope<'_>, + msg: &DescriptorProto, + view_ident: &proc_macro2::Ident, + view_depth: usize, + view_oneof_prefix: &TokenStream, + oneof_idents: &HashMap, +) -> Result { + let MessageScope { ctx, .. } = view_scope; + let features = view_scope.features; + let vr = quote! { ::buffa_descriptor::reflect::ValueRef }; + let cow = quote! { ::buffa_descriptor::reflect::ReflectCow }; + + let mut get_arms: Vec = Vec::new(); + let mut has_arms: Vec = Vec::new(); + + // Direct (non-oneof) fields. + for field in &msg.field { + if is_real_oneof_member(field) { + continue; + } + let ty = effective_type(ctx, field, features); + if !is_supported_field_type(ty) { + continue; + } + let name = field + .name + .as_deref() + .ok_or(CodeGenError::MissingField("field.name"))?; + let id = make_field_ident(name); + // `FieldDescriptor::number()` (matched on below) returns `u32`; proto + // field numbers are always positive. + let number = field.number.unwrap_or(0) as u32; + let is_repeated = field.label.unwrap_or_default() == Label::LABEL_REPEATED; + + if is_repeated && is_map_field(msg, field) { + get_arms.push(quote! { #number => #vr::Map(&self.#id), }); + has_arms.push(quote! { #number => !::buffa::MapView::is_empty(&self.#id), }); + continue; + } + if is_repeated { + get_arms.push(quote! { #number => #vr::List(&self.#id), }); + has_arms.push(quote! { #number => !::buffa::RepeatedView::is_empty(&self.#id), }); + continue; + } + + let f_features = resolve_field(ctx, field, features); + let (get_val, has_val) = if is_explicit_presence_scalar(field, ty, &f_features) { + // Stored as `Option`; absent singular returns the type default. + match ty { + Type::TYPE_STRING => ( + quote! { #vr::String(self.#id.unwrap_or("")) }, + quote! { self.#id.is_some() }, + ), + Type::TYPE_BYTES => ( + quote! { #vr::Bytes(self.#id.unwrap_or(&[])) }, + quote! { self.#id.is_some() }, + ), + Type::TYPE_ENUM => ( + quote! { #vr::EnumNumber(self.#id.map_or(0, |e| e.to_i32())) }, + quote! { self.#id.is_some() }, + ), + _ => { + let variant = scalar_variant(ty); + let def = scalar_default(ty); + ( + quote! { #vr::#variant(self.#id.unwrap_or(#def)) }, + quote! { self.#id.is_some() }, + ) + } + } + } else { + // Implicit presence: absent is the default value, present is + // non-default. proto2 `required` fields also fall here (they are + // stored as bare types, not `Option`), so a required field set to + // its type default reflects as `has() == false` — the view layer + // cannot distinguish wire-set-to-default from absent. + match ty { + Type::TYPE_STRING => ( + quote! { #vr::String(self.#id) }, + quote! { !self.#id.is_empty() }, + ), + Type::TYPE_BYTES => ( + quote! { #vr::Bytes(self.#id) }, + quote! { !self.#id.is_empty() }, + ), + Type::TYPE_MESSAGE | Type::TYPE_GROUP => ( + // `MessageFieldView` derefs to the inner view, or the static + // default instance when unset — so the borrow is always + // valid and absent fields read as the empty message. + quote! { #vr::Message(#cow::Borrowed(&*self.#id)) }, + quote! { self.#id.is_set() }, + ), + Type::TYPE_ENUM => { + // A closed enum's default need not be zero (editions allows + // a non-zero first value), so "non-default" compares against + // the type default rather than `to_i32() != 0`. Open enums + // (`EnumValue`) always default to the zero wire value. + let has_val = if is_closed_enum(&f_features) { + quote! { self.#id != ::core::default::Default::default() } + } else { + quote! { self.#id.to_i32() != 0 } + }; + (quote! { #vr::EnumNumber(self.#id.to_i32()) }, has_val) + } + _ => { + let variant = scalar_variant(ty); + let has_val = match ty { + Type::TYPE_BOOL => quote! { self.#id }, + Type::TYPE_FLOAT | Type::TYPE_DOUBLE => quote! { self.#id != 0.0 }, + _ => quote! { self.#id != 0 }, + }; + (quote! { #vr::#variant(self.#id) }, has_val) + } + } + }; + get_arms.push(quote! { #number => #get_val, }); + has_arms.push(quote! { #number => #has_val, }); + } + + // Oneof members dispatch through the `Option` struct field. + for (idx, oneof) in msg.oneof_decl.iter().enumerate() { + let Some(base_ident) = oneof_idents.get(&idx) else { + continue; + }; + let oneof_name = oneof + .name + .as_deref() + .ok_or(CodeGenError::MissingField("oneof.name"))?; + let field_ident = make_field_ident(oneof_name); + let view_enum = quote! { #view_oneof_prefix #base_ident }; + + for field in msg + .field + .iter() + .filter(|f| is_real_oneof_member(f) && f.oneof_index == Some(idx as i32)) + { + let name = field + .name + .as_deref() + .ok_or(CodeGenError::MissingField("field.name"))?; + let number = field.number.unwrap_or(0) as u32; + let variant = oneof_variant_ident(name); + let ty = effective_type(ctx, field, features); + + let (active, default) = match ty { + Type::TYPE_STRING => (quote! { #vr::String(v) }, quote! { #vr::String("") }), + Type::TYPE_BYTES => (quote! { #vr::Bytes(v) }, quote! { #vr::Bytes(&[]) }), + Type::TYPE_MESSAGE | Type::TYPE_GROUP => { + let view_ty = resolve_view_ty_tokens(view_scope, field)?; + ( + quote! { #vr::Message(#cow::Borrowed(&**v)) }, + quote! { + #vr::Message(#cow::Borrowed( + <#view_ty as ::buffa::view::DefaultViewInstance>::default_view_instance(), + )) + }, + ) + } + Type::TYPE_ENUM => ( + quote! { #vr::EnumNumber(v.to_i32()) }, + quote! { #vr::EnumNumber(0) }, + ), + _ => { + let variant_v = scalar_variant(ty); + let def = scalar_default(ty); + ( + quote! { #vr::#variant_v(*v) }, + quote! { #vr::#variant_v(#def) }, + ) + } + }; + + get_arms.push(quote! { + #number => match &self.#field_ident { + ::core::option::Option::Some(#view_enum::#variant(v)) => #active, + _ => #default, + }, + }); + has_arms.push(quote! { + #number => ::core::matches!( + &self.#field_ident, + ::core::option::Option::Some(#view_enum::#variant(_)) + ), + }); + } + } + + // Path from the view module back to `__buffa::reflect::descriptor_pool()`. + let mut supers = TokenStream::new(); + for _ in 0..view_depth { + supers.extend(quote! { super:: }); + } + let sentinel = make_field_ident(SENTINEL_MOD); + let pool = quote! { #supers #sentinel::reflect::descriptor_pool() }; + + Ok(quote! { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for #view_ident<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + #pool.message(Self::__buffa_reflect_message_index()) + } + + fn pool(&self) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + #pool + } + + fn get(&self, field: &::buffa_descriptor::FieldDescriptor) -> #vr<'_> { + // Closed enums are stored as the bare enum type, whose `to_i32` + // is the `Enumeration` trait method (open enums use the inherent + // `EnumValue::to_i32`, which needs no import). No-op for messages + // without enum fields. + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + #(#get_arms)* + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + #vr::Bool(false) + } + } + } + + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + #(#has_arms)* + _ => false, + } + } + + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut(&::buffa_descriptor::FieldDescriptor, #vr<'_>), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor(self); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + // The one allocating path in vtable mode (an explicit owned + // snapshot — plain field reads never reach it). Encode the view + // directly and decode into a `DynamicMessage`, skipping the + // intermediate owned-message tree that `from_message` would build. + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone(#pool), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + + impl<'a> ::buffa_descriptor::reflect::ReflectElement for #view_ident<'a> { + fn as_value_ref(&self) -> #vr<'_> { + #vr::Message(#cow::Borrowed(self)) + } + } + + impl<'a> #view_ident<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = + ::std::sync::OnceLock::new(); + *IDX.get_or_init(|| { + #pool + .message_index(::FULL_NAME) + .expect("generated view type is registered in the embedded descriptor pool") + }) + } + } + }) +} diff --git a/buffa-codegen/src/tests/mod.rs b/buffa-codegen/src/tests/mod.rs index 626390e..b505407 100644 --- a/buffa-codegen/src/tests/mod.rs +++ b/buffa-codegen/src/tests/mod.rs @@ -57,4 +57,5 @@ mod json_codegen; mod naming; mod proto2; mod reexports; +mod reflect_view; mod view_codegen; diff --git a/buffa-codegen/src/tests/reflect_view.rs b/buffa-codegen/src/tests/reflect_view.rs new file mode 100644 index 0000000..4a43a49 --- /dev/null +++ b/buffa-codegen/src/tests/reflect_view.rs @@ -0,0 +1,101 @@ +//! Vtable-mode reflection codegen: config validation and emitted impls. + +use super::*; + +/// A config with both bridge reflection and vtable mode enabled. +fn vtable_config() -> CodeGenConfig { + CodeGenConfig { + generate_reflection: true, + generate_reflection_vtable: true, + ..Default::default() + } +} + +/// A small proto3 message with a scalar and a string field. +fn msg_file() -> FileDescriptorProto { + let mut file = proto3_file("vt.proto"); + file.message_type.push(DescriptorProto { + name: Some("Msg".to_string()), + field: vec![ + make_field("id", 1, Label::LABEL_OPTIONAL, Type::TYPE_INT32), + make_field("name", 2, Label::LABEL_OPTIONAL, Type::TYPE_STRING), + ], + ..Default::default() + }); + file +} + +#[test] +fn vtable_emits_reflect_message_and_element_impls() { + let files = generate(&[msg_file()], &["vt.proto".to_string()], &vtable_config()) + .expect("should generate"); + let content = joined(&files); + + assert!( + content.contains("impl<'a> ::buffa_descriptor::reflect::ReflectMessage for MsgView<'a>"), + "vtable mode must emit ReflectMessage for the view: {content}" + ); + assert!( + content.contains("impl<'a> ::buffa_descriptor::reflect::ReflectElement for MsgView<'a>"), + "vtable mode must emit ReflectElement for the view: {content}" + ); + // The memoized index accessor is an inherent associated fn (collision-free + // across sibling views). + assert!( + content.contains("fn __buffa_reflect_message_index()"), + "vtable mode must emit the memoized MessageIndex accessor: {content}" + ); +} + +#[test] +fn vtable_without_reflection_is_rejected() { + let config = CodeGenConfig { + generate_reflection: false, + generate_reflection_vtable: true, + ..Default::default() + }; + let err = generate(&[msg_file()], &["vt.proto".to_string()], &config) + .expect_err("vtable without reflection must error"); + assert!( + err.to_string().contains("generate_reflection"), + "error should name the missing prerequisite: {err}" + ); +} + +#[test] +fn vtable_without_views_is_rejected() { + let config = CodeGenConfig { + generate_reflection: true, + generate_reflection_vtable: true, + generate_views: false, + ..Default::default() + }; + let err = generate(&[msg_file()], &["vt.proto".to_string()], &config) + .expect_err("vtable without views must error"); + assert!( + err.to_string().contains("generate_views"), + "error should name the missing prerequisite: {err}" + ); +} + +#[test] +fn bridge_only_does_not_emit_vtable_impls() { + let config = CodeGenConfig { + generate_reflection: true, + generate_reflection_vtable: false, + ..Default::default() + }; + let files = + generate(&[msg_file()], &["vt.proto".to_string()], &config).expect("should generate"); + let content = joined(&files); + // Bridge mode emits Reflectable on the owned type but no ReflectMessage on + // the view. + assert!( + content.contains("impl ::buffa_descriptor::reflect::Reflectable for Msg"), + "bridge mode must still emit Reflectable: {content}" + ); + assert!( + !content.contains("ReflectMessage for MsgView"), + "bridge-only must not emit the vtable ReflectMessage impl: {content}" + ); +} diff --git a/buffa-codegen/src/view.rs b/buffa-codegen/src/view.rs index 9057047..744a85f 100644 --- a/buffa-codegen/src/view.rs +++ b/buffa-codegen/src/view.rs @@ -192,6 +192,37 @@ pub(crate) fn generate_view_with_nesting( quote! {} }; + // Vtable-mode reflection: `impl ReflectMessage` directly on the view. + // Skipped for map entry synthetic messages (not registered in the pool by + // name; consumers never reflect over them directly), matching the + // bridge-mode `Reflectable` skip. + let is_map_entry = msg + .options + .as_option() + .is_some_and(|o| o.map_entry.unwrap_or(false)); + let reflect_view_impls = + if ctx.config.generate_reflection && ctx.config.generate_reflection_vtable && !is_map_entry + { + // `reflect_view_impls` emits three sibling items (the ReflectMessage + // impl, the ReflectElement impl, and an inherent impl for the + // memoized index). `cfg_const_block` wraps them in a single + // `#[cfg] const _` so one gate covers all three; a bare `cfg_block` + // would gate only the first and leak the rest. + crate::feature_gates::cfg_const_block( + crate::reflect_view::reflect_view_impls( + view_scope, + msg, + &view_ident, + view_depth, + &view_oneof_prefix, + &oneof_idents, + )?, + ctx.config.feature_gates().reflect, + ) + } else { + quote! {} + }; + // When preserving unknowns we capture `before_tag` so we can compute the // raw byte span after `skip_field` advances the cursor. let before_tag_capture = if ctx.config.preserve_unknown_fields { @@ -369,6 +400,8 @@ pub(crate) fn generate_view_with_nesting( this } } + + #reflect_view_impls }; Ok((top_level, mod_items)) @@ -2243,7 +2276,7 @@ fn resolve_enum_ty( /// `scope.nesting` must be the **total** depth of the caller below the /// package root (msg-nesting + kind-depth offset already applied by the /// caller — `+2` for view-struct bodies, `+4` for view-oneof-enum bodies). -fn resolve_view_ty_tokens( +pub(crate) fn resolve_view_ty_tokens( scope: MessageScope<'_>, field: &FieldDescriptorProto, ) -> Result { diff --git a/buffa-test/build.rs b/buffa-test/build.rs index 4d7a171..d1b70cf 100644 --- a/buffa-test/build.rs +++ b/buffa-test/build.rs @@ -7,6 +7,7 @@ fn main() { .includes(&["protos/"]) .generate_text(true) .generate_reflection(true) + .generate_reflection_vtable(true) .compile() .expect("buffa_build failed for basic.proto"); @@ -79,11 +80,17 @@ fn main() { .compile() .expect("buffa_build failed for nestpkg_*.proto"); - // Proto2 with custom defaults, required fields, closed enums. + // Proto2 with custom defaults, required fields, closed enums. Vtable + // reflection is enabled here specifically to compile the closed-enum and + // required-field reflect paths (basic.proto is proto3 / open enums only): + // closed enums are stored as bare enum types, whose `to_i32` is the + // `Enumeration` trait method. buffa_build::Config::new() .files(&["protos/proto2_defaults.proto"]) .includes(&["protos/"]) .generate_text(true) + .generate_reflection(true) + .generate_reflection_vtable(true) .compile() .expect("buffa_build failed for proto2_defaults.proto"); diff --git a/buffa-test/tests/reflect_vtable.rs b/buffa-test/tests/reflect_vtable.rs new file mode 100644 index 0000000..9f2c269 --- /dev/null +++ b/buffa-test/tests/reflect_vtable.rs @@ -0,0 +1,223 @@ +//! Vtable test: reflect directly over a decoded zero-copy view. +//! +//! Unlike `reflect_bridge.rs` (which round-trips through `DynamicMessage`), +//! these tests exercise the generated `impl ReflectMessage for FooView<'a>` — +//! `get`/`has`/`for_each_set` read view struct fields directly, with no +//! encode/decode round-trip and no per-field allocation. The view is produced +//! by `decode_view` straight from wire bytes, which is the entry point a +//! reflection consumer holding raw bytes (an interceptor, a field-mask +//! evaluator) uses. + +use buffa::{Message, MessageView}; +use buffa_descriptor::reflect::{MapKey, ReflectMessage, ValueRef}; +use buffa_test::basic::*; + +/// A representative Person, encoded to wire bytes. +fn person_bytes() -> Vec { + let person = Person { + id: 42, + name: "Ada".into(), + avatar: vec![0xDE, 0xAD], + verified: true, + score: 9.5, + status: Status::ACTIVE.into(), + address: buffa::MessageField::some(Address { + street: "1 Main".into(), + city: "Somewhere".into(), + zip_code: 12345, + ..Default::default() + }), + tags: vec!["x".into(), "y".into()], + lucky_numbers: vec![7, 11, 13], + maybe_age: Some(30), + contact: Some(person::Contact::Email("ada@example.com".into())), + ..Default::default() + }; + person.encode_to_vec() +} + +#[test] +fn vtable_view_scalar_and_string_fields() { + let bytes = person_bytes(); + let view = PersonView::decode_view(&bytes).expect("decode_view"); + // Exercise the dyn-safe path: a reflection consumer (interceptor, + // field-mask evaluator) holds `&dyn ReflectMessage`, not the concrete view. + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + + // Field 1: id (int32) — scalar copy. + assert!(matches!(r.get(md.field(1).unwrap()), ValueRef::I32(42))); + // Field 2: name (string) — borrowed from the wire buffer, no allocation. + assert!(matches!( + r.get(md.field(2).unwrap()), + ValueRef::String("Ada") + )); + // Field 3: avatar (bytes) — borrowed. + let ValueRef::Bytes(avatar) = r.get(md.field(3).unwrap()) else { + panic!("expected Bytes") + }; + assert_eq!(avatar, &[0xDE, 0xAD]); + // Field 4: verified (bool). + assert!(matches!(r.get(md.field(4).unwrap()), ValueRef::Bool(true))); + // Field 5: score (double). + assert!(matches!(r.get(md.field(5).unwrap()), ValueRef::F64(9.5))); + // Field 6: status (open enum) — ACTIVE is 1. + assert!(matches!( + r.get(md.field(6).unwrap()), + ValueRef::EnumNumber(1) + )); +} + +#[test] +fn vtable_view_message_field_borrows() { + let bytes = person_bytes(); + let view = PersonView::decode_view(&bytes).expect("decode_view"); + // Exercise the dyn-safe path: a reflection consumer (interceptor, + // field-mask evaluator) holds `&dyn ReflectMessage`, not the concrete view. + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + + // Field 7: address (nested message) — reflected without materializing. + let ValueRef::Message(cow) = r.get(md.field(7).unwrap()) else { + panic!("expected Message") + }; + let addr_md = cow.message_descriptor(); + assert!(matches!( + cow.get(addr_md.field(1).unwrap()), + ValueRef::String("1 Main") + )); + assert!(matches!( + cow.get(addr_md.field(2).unwrap()), + ValueRef::String("Somewhere") + )); +} + +#[test] +fn vtable_view_repeated_fields() { + let bytes = person_bytes(); + let view = PersonView::decode_view(&bytes).expect("decode_view"); + // Exercise the dyn-safe path: a reflection consumer (interceptor, + // field-mask evaluator) holds `&dyn ReflectMessage`, not the concrete view. + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + + // Field 8: tags (repeated string). + let ValueRef::List(tags) = r.get(md.field(8).unwrap()) else { + panic!("expected List") + }; + assert_eq!(tags.len(), 2); + assert!(matches!(tags.get(0), Some(ValueRef::String("x")))); + assert!(matches!(tags.get(1), Some(ValueRef::String("y")))); + + // Field 9: lucky_numbers (repeated int32, packed). + let ValueRef::List(nums) = r.get(md.field(9).unwrap()) else { + panic!("expected List") + }; + assert_eq!(nums.len(), 3); + let mut sum = 0; + nums.for_each(&mut |v| { + if let ValueRef::I32(n) = v { + sum += n; + } + }); + assert_eq!(sum, 31); +} + +#[test] +fn vtable_view_presence_and_oneof() { + let bytes = person_bytes(); + let view = PersonView::decode_view(&bytes).expect("decode_view"); + // Exercise the dyn-safe path: a reflection consumer (interceptor, + // field-mask evaluator) holds `&dyn ReflectMessage`, not the concrete view. + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + + // Field 11: maybe_age (proto3 optional int32) — set. + assert!(r.has(md.field(11).unwrap())); + assert!(matches!(r.get(md.field(11).unwrap()), ValueRef::I32(30))); + // Field 12: maybe_nickname — not set; has() false, get() returns default. + assert!(!r.has(md.field(12).unwrap())); + assert!(matches!(r.get(md.field(12).unwrap()), ValueRef::String(""))); + // Field 13: contact.email (oneof string variant) — active. + assert!(r.has(md.field(13).unwrap())); + assert!(matches!( + r.get(md.field(13).unwrap()), + ValueRef::String("ada@example.com") + )); +} + +#[test] +fn vtable_for_each_set_visits_set_fields() { + // Only id and name set; after wire round-trip the rest are default. + let person = Person { + id: 1, + name: "B".into(), + ..Default::default() + }; + let bytes = person.encode_to_vec(); + let view = PersonView::decode_view(&bytes).expect("decode_view"); + // Exercise the dyn-safe path: a reflection consumer (interceptor, + // field-mask evaluator) holds `&dyn ReflectMessage`, not the concrete view. + let r: &dyn ReflectMessage = &view; + + let mut numbers = Vec::new(); + r.for_each_set(&mut |fd, _| numbers.push(fd.number())); + numbers.sort_unstable(); + assert_eq!(numbers, vec![1u32, 2u32]); +} + +#[test] +fn vtable_map_field() { + let mut stock = std::collections::HashMap::new(); + stock.insert("apples".to_string(), 3); + stock.insert("oranges".to_string(), 7); + let inv = Inventory { + stock, + ..Default::default() + }; + let bytes = inv.encode_to_vec(); + let view = InventoryView::decode_view(&bytes).expect("decode_view"); + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + + let stock_fd = md + .fields() + .iter() + .find(|f| f.name() == "stock") + .expect("stock field"); + let ValueRef::Map(m) = r.get(stock_fd) else { + panic!("expected Map") + }; + assert_eq!(m.len(), 2); + // No-alloc string lookup (the CEL hot path). + assert!(matches!(m.get_str("apples"), Some(ValueRef::I32(3)))); + assert!(matches!(m.get_str("oranges"), Some(ValueRef::I32(7)))); + assert!(m.get_str("durian").is_none()); + // Descriptor-keyed lookup. + assert!(matches!( + m.get(&MapKey::String("apples".into())), + Some(ValueRef::I32(3)) + )); +} + +#[test] +fn vtable_to_dynamic_snapshot() { + // `to_dynamic()` falls back to a bridge-style materialization for consumers + // that need an owned snapshot. + let bytes = person_bytes(); + let view = PersonView::decode_view(&bytes).expect("decode_view"); + // Exercise the dyn-safe path: a reflection consumer (interceptor, + // field-mask evaluator) holds `&dyn ReflectMessage`, not the concrete view. + let r: &dyn ReflectMessage = &view; + + let snapshot = r.to_dynamic(); + let snap_md = snapshot.message_descriptor(); + assert!(matches!( + snapshot.get(snap_md.field(2).unwrap()), + ValueRef::String("Ada") + )); + assert!(matches!( + snapshot.get(snap_md.field(1).unwrap()), + ValueRef::I32(42) + )); +} From a40773f542d7408852719fb3bde4171260cedb46 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 00:39:25 +0000 Subject: [PATCH 03/12] buffa-types: reflection for well-known-type views MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Make the WKT view types (TimestampView, DurationView, AnyView, StructView, ValueView, wrappers, etc.) implement ReflectMessage, so a message that has a WKT field can reflect over it. Previously vtable reflection only worked for protos that did not reference WKTs, because the WKT views lived in buffa-types with no path to ReflectMessage. The reflection surface pulls a buffa-descriptor dependency and requires std (the embedded descriptor pool uses OnceLock), so it is gated behind a new buffa-types `reflect` feature; views and text stay unconditional. This is enabled by a targeted codegen flag, gate_reflect_on_crate_feature, which gates only the reflection impls — unlike gate_impls_on_crate_features, which gates json/views/text/reflect together and would have forced buffa-types consumers to opt into views/text. All seven WKT protos share the google.protobuf package, so one embedded descriptor pool backs every WKT view's reflection. --- Cargo.lock | 1 + buffa-codegen/src/bin/gen_wkt_types.rs | 8 + buffa-codegen/src/feature_gates.rs | 63 +- buffa-codegen/src/lib.rs | 28 + buffa-types/Cargo.toml | 8 + .../generated/google.protobuf.any.__view.rs | 92 + .../src/generated/google.protobuf.any.rs | 43 + .../google.protobuf.duration.__view.rs | 92 + .../src/generated/google.protobuf.duration.rs | 43 + .../generated/google.protobuf.empty.__view.rs | 88 + .../src/generated/google.protobuf.empty.rs | 43 + .../google.protobuf.field_mask.__view.rs | 90 + .../generated/google.protobuf.field_mask.rs | 43 + .../src/generated/google.protobuf.mod.rs | 3019 +++++++++++++++++ .../google.protobuf.struct.__view.rs | 384 +++ .../src/generated/google.protobuf.struct.rs | 129 + .../google.protobuf.timestamp.__view.rs | 92 + .../generated/google.protobuf.timestamp.rs | 43 + .../google.protobuf.wrappers.__view.rs | 810 +++++ .../src/generated/google.protobuf.wrappers.rs | 387 +++ buffa-types/src/lib.rs | 13 + buffa-types/tests/wkt_reflect.rs | 117 + 22 files changed, 5629 insertions(+), 7 deletions(-) create mode 100644 buffa-types/tests/wkt_reflect.rs diff --git a/Cargo.lock b/Cargo.lock index 0acfaa9..04e98f6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -136,6 +136,7 @@ version = "0.6.0" dependencies = [ "arbitrary", "buffa", + "buffa-descriptor", "bytes", "criterion", "serde", diff --git a/buffa-codegen/src/bin/gen_wkt_types.rs b/buffa-codegen/src/bin/gen_wkt_types.rs index cc5ca0a..e661383 100644 --- a/buffa-codegen/src/bin/gen_wkt_types.rs +++ b/buffa-codegen/src/bin/gen_wkt_types.rs @@ -93,6 +93,14 @@ fn main() { config.generate_json = false; config.generate_text = true; config.emit_register_fn = false; + // Vtable reflection for the WKT views (`impl ReflectMessage for TimestampView` + // etc.), so consumer protos that reference WKTs can reflect over them. The + // reflection surface pulls a `buffa-descriptor` dependency and `std`, so it + // is gated behind buffa-types' `reflect` feature via + // `gate_reflect_on_crate_feature` — views and text stay unconditional. + config.generate_reflection = true; + config.generate_reflection_vtable = true; + config.gate_reflect_on_crate_feature = true; // `Any.value` carries arbitrary encoded payloads that callers commonly // cache and clone into `repeated google.protobuf.Any` response fields. // `Bytes::clone()` is a refcount bump rather than a payload memcpy. diff --git a/buffa-codegen/src/feature_gates.rs b/buffa-codegen/src/feature_gates.rs index a62b5b3..3f51e9a 100644 --- a/buffa-codegen/src/feature_gates.rs +++ b/buffa-codegen/src/feature_gates.rs @@ -48,15 +48,20 @@ pub(crate) struct FeatureGates { impl FeatureGates { /// Compute the active gates for a config. + /// + /// `gate_impls_on_crate_features` gates json/views/text/reflect together. + /// When it is off, `gate_reflect_on_crate_feature` turns on reflect-only + /// gating — for crates (notably `buffa-types`) that ship views/text + /// unconditionally but want the `buffa-descriptor`-dependent reflection + /// surface to be opt-in. pub(crate) fn for_config(config: &CodeGenConfig) -> Self { - if !config.gate_impls_on_crate_features { - return Self::default(); - } + let gate_all = config.gate_impls_on_crate_features; + let gate_reflect = gate_all || config.gate_reflect_on_crate_feature; Self { - json: config.generate_json.then_some(JSON_FEATURE), - views: config.generate_views.then_some(VIEWS_FEATURE), - text: config.generate_text.then_some(TEXT_FEATURE), - reflect: config.generate_reflection.then_some(REFLECT_FEATURE), + json: (gate_all && config.generate_json).then_some(JSON_FEATURE), + views: (gate_all && config.generate_views).then_some(VIEWS_FEATURE), + text: (gate_all && config.generate_text).then_some(TEXT_FEATURE), + reflect: (gate_reflect && config.generate_reflection).then_some(REFLECT_FEATURE), } } @@ -226,6 +231,50 @@ mod tests { assert_eq!(gates.json_or_text(), vec![JSON_FEATURE, TEXT_FEATURE]); } + #[test] + fn for_config_reflect_only_gate() { + // `gate_reflect_on_crate_feature` gates reflect without gating + // json/views/text — the `buffa-types` shape. + let config = CodeGenConfig { + generate_json: true, + generate_views: true, + generate_text: true, + generate_reflection: true, + gate_reflect_on_crate_feature: true, + ..CodeGenConfig::default() + }; + let gates = FeatureGates::for_config(&config); + assert_eq!(gates.json, None); + assert_eq!(gates.views, None); + assert_eq!(gates.text, None); + assert_eq!(gates.reflect, Some(REFLECT_FEATURE)); + } + + #[test] + fn for_config_reflect_gate_requires_generate_reflection() { + // The gate flag is inert unless reflection is actually generated. + let config = CodeGenConfig { + generate_reflection: false, + gate_reflect_on_crate_feature: true, + ..CodeGenConfig::default() + }; + assert_eq!(FeatureGates::for_config(&config).reflect, None); + } + + #[test] + fn for_config_umbrella_gate_includes_reflect() { + // `gate_impls_on_crate_features` also gates reflect when reflection is on. + let config = CodeGenConfig { + generate_reflection: true, + gate_impls_on_crate_features: true, + ..CodeGenConfig::default() + }; + assert_eq!( + FeatureGates::for_config(&config).reflect, + Some(REFLECT_FEATURE) + ); + } + #[test] fn json_or_text_subsets() { let none = FeatureGates::default(); diff --git a/buffa-codegen/src/lib.rs b/buffa-codegen/src/lib.rs index 9afc87f..ef2da83 100644 --- a/buffa-codegen/src/lib.rs +++ b/buffa-codegen/src/lib.rs @@ -405,6 +405,12 @@ pub struct CodeGenConfig { /// `feature = "arbitrary"` regardless of this flag, because `arbitrary` /// is an optional dependency by design. /// + /// When [`generate_reflection`](Self::generate_reflection) is also on, the + /// reflection impls are gated on `feature = "reflect"` alongside + /// json/views/text. To gate *only* reflection without gating json/views/text, + /// use [`gate_reflect_on_crate_feature`](Self::gate_reflect_on_crate_feature) + /// instead. + /// /// This is the mechanism that lets `buffa-descriptor` and `buffa-types` /// ship every impl while keeping the codegen toolchain /// (`buffa-codegen`/`buffa-build`/`protoc-gen-buffa`) lean: those crates @@ -484,6 +490,27 @@ pub struct CodeGenConfig { /// /// Defaults to `false`. pub generate_reflection_vtable: bool, + /// Gate the reflection impls behind a `reflect` crate feature, *without* + /// gating json/views/text (unlike + /// [`gate_impls_on_crate_features`](Self::gate_impls_on_crate_features), + /// which gates them all together). + /// + /// Used by crates that ship view/text impls unconditionally but want the + /// reflection surface — which pulls a `buffa-descriptor` dependency and + /// `std` — to be opt-in. `buffa-types` is the motivating case: its WKT + /// views are always available, but `impl ReflectMessage` for them is gated + /// behind `buffa-types`'s `reflect` feature. + /// + /// When [`gate_impls_on_crate_features`](Self::gate_impls_on_crate_features) + /// is already on, reflection is gated regardless and this flag is ignored. + /// + /// This is a low-level knob for internal codegen tooling (it is set + /// directly by `gen_wkt_types`) and is not surfaced through `buffa-build`, + /// whose consumers ship a single crate and rarely need feature-gated + /// reflection. + /// + /// Defaults to `false`. + pub gate_reflect_on_crate_feature: bool, } impl Default for CodeGenConfig { @@ -509,6 +536,7 @@ impl Default for CodeGenConfig { generate_with_setters: true, generate_reflection: false, generate_reflection_vtable: false, + gate_reflect_on_crate_feature: false, } } } diff --git a/buffa-types/Cargo.toml b/buffa-types/Cargo.toml index ccdff87..632820d 100644 --- a/buffa-types/Cargo.toml +++ b/buffa-types/Cargo.toml @@ -18,12 +18,20 @@ default = ["std"] std = ["buffa/std", "thiserror/std", "serde?/std", "serde_json?/std"] json = ["dep:serde", "dep:serde_json", "buffa/json"] arbitrary = ["dep:arbitrary", "buffa/arbitrary"] +# Runtime reflection for the WKT views (`impl ReflectMessage for TimestampView`, +# etc.) and owned types. Pulls `buffa-descriptor` and requires `std` (the +# embedded descriptor pool uses `std::sync::OnceLock`). Off by default so +# `no_std` consumers and those that don't reflect pay nothing. +reflect = ["dep:buffa-descriptor", "buffa-descriptor/reflect", "std"] [dependencies] arbitrary = { workspace = true, optional = true } # `buffa/text` is zero-dep and the WKT generated code unconditionally impls # `TextFormat` — enabled here so the checked-in src/generated/ always compiles. buffa = { workspace = true, default-features = false, features = ["text"] } +# Optional: only when the `reflect` feature is on. The generated WKT reflect +# impls reference `::buffa_descriptor::reflect::*`. +buffa-descriptor = { workspace = true, optional = true } # Generated `Any.value: Bytes` (via `bytes_fields` in gen_wkt_types) emits # `::bytes::Bytes` paths, so the crate is referenced directly. bytes = { workspace = true } diff --git a/buffa-types/src/generated/google.protobuf.any.__view.rs b/buffa-types/src/generated/google.protobuf.any.__view.rs index addd6c1..846ce55 100644 --- a/buffa-types/src/generated/google.protobuf.any.__view.rs +++ b/buffa-types/src/generated/google.protobuf.any.__view.rs @@ -305,3 +305,95 @@ impl ::buffa::ViewReborrow for AnyView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for AnyView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::String(self.type_url), + 2u32 => ::buffa_descriptor::reflect::ValueRef::Bytes(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.type_url.is_empty(), + 2u32 => !self.value.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for AnyView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> AnyView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; diff --git a/buffa-types/src/generated/google.protobuf.any.rs b/buffa-types/src/generated/google.protobuf.any.rs index 29bf12e..c8d3ce9 100644 --- a/buffa-types/src/generated/google.protobuf.any.rs +++ b/buffa-types/src/generated/google.protobuf.any.rs @@ -164,6 +164,49 @@ impl ::buffa::DefaultInstance for Any { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Any { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Any { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Any"; diff --git a/buffa-types/src/generated/google.protobuf.duration.__view.rs b/buffa-types/src/generated/google.protobuf.duration.__view.rs index 70fad8c..aa4ea21 100644 --- a/buffa-types/src/generated/google.protobuf.duration.__view.rs +++ b/buffa-types/src/generated/google.protobuf.duration.__view.rs @@ -246,3 +246,95 @@ impl ::buffa::ViewReborrow for DurationView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for DurationView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I64(self.seconds), + 2u32 => ::buffa_descriptor::reflect::ValueRef::I32(self.nanos), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.seconds != 0, + 2u32 => self.nanos != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for DurationView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> DurationView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; diff --git a/buffa-types/src/generated/google.protobuf.duration.rs b/buffa-types/src/generated/google.protobuf.duration.rs index ad7fd48..811bf90 100644 --- a/buffa-types/src/generated/google.protobuf.duration.rs +++ b/buffa-types/src/generated/google.protobuf.duration.rs @@ -107,6 +107,49 @@ impl ::buffa::DefaultInstance for Duration { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Duration { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Duration { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Duration"; diff --git a/buffa-types/src/generated/google.protobuf.empty.__view.rs b/buffa-types/src/generated/google.protobuf.empty.__view.rs index efba066..10d5fec 100644 --- a/buffa-types/src/generated/google.protobuf.empty.__view.rs +++ b/buffa-types/src/generated/google.protobuf.empty.__view.rs @@ -138,3 +138,91 @@ impl ::buffa::ViewReborrow for EmptyView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for EmptyView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for EmptyView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> EmptyView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; diff --git a/buffa-types/src/generated/google.protobuf.empty.rs b/buffa-types/src/generated/google.protobuf.empty.rs index d546cbc..f3adc0d 100644 --- a/buffa-types/src/generated/google.protobuf.empty.rs +++ b/buffa-types/src/generated/google.protobuf.empty.rs @@ -34,6 +34,49 @@ impl ::buffa::DefaultInstance for Empty { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Empty { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Empty { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Empty"; diff --git a/buffa-types/src/generated/google.protobuf.field_mask.__view.rs b/buffa-types/src/generated/google.protobuf.field_mask.__view.rs index a39dba1..b82ab0c 100644 --- a/buffa-types/src/generated/google.protobuf.field_mask.__view.rs +++ b/buffa-types/src/generated/google.protobuf.field_mask.__view.rs @@ -378,3 +378,93 @@ impl ::buffa::ViewReborrow for FieldMaskView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for FieldMaskView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::List(&self.paths), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !::buffa::RepeatedView::is_empty(&self.paths), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for FieldMaskView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> FieldMaskView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; diff --git a/buffa-types/src/generated/google.protobuf.field_mask.rs b/buffa-types/src/generated/google.protobuf.field_mask.rs index b562721..592ff41 100644 --- a/buffa-types/src/generated/google.protobuf.field_mask.rs +++ b/buffa-types/src/generated/google.protobuf.field_mask.rs @@ -252,6 +252,49 @@ impl ::buffa::DefaultInstance for FieldMask { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for FieldMask { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for FieldMask { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "FieldMask"; diff --git a/buffa-types/src/generated/google.protobuf.mod.rs b/buffa-types/src/generated/google.protobuf.mod.rs index c94798e..abd823e 100644 --- a/buffa-types/src/generated/google.protobuf.mod.rs +++ b/buffa-types/src/generated/google.protobuf.mod.rs @@ -42,7 +42,3026 @@ pub mod __buffa { use super::*; include!("google.protobuf.struct.__oneof.rs"); } + #[cfg(feature = "reflect")] + /// Reflection support: embedded descriptor pool for bridge-mode + /// [`Reflectable`](::buffa_descriptor::reflect::Reflectable) impls. + pub mod reflect { + /// The serialized `FileDescriptorSet` for this codegen run, + /// including transitive dependencies. Used to build the + /// runtime [`DescriptorPool`](::buffa_descriptor::DescriptorPool). + pub const FILE_DESCRIPTOR_SET_BYTES: &[u8] = &[ + 10u8, 196u8, 46u8, 10u8, 25u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 47u8, 97u8, + 110u8, 121u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 18u8, 15u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 98u8, 117u8, 102u8, 34u8, 54u8, 10u8, 3u8, 65u8, 110u8, 121u8, 18u8, 25u8, + 10u8, 8u8, 116u8, 121u8, 112u8, 101u8, 95u8, 117u8, 114u8, 108u8, 24u8, 1u8, + 32u8, 1u8, 40u8, 9u8, 82u8, 7u8, 116u8, 121u8, 112u8, 101u8, 85u8, 114u8, + 108u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, 2u8, + 32u8, 1u8, 40u8, 12u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 66u8, + 118u8, 10u8, 19u8, 99u8, 111u8, 109u8, 46u8, 103u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, + 66u8, 8u8, 65u8, 110u8, 121u8, 80u8, 114u8, 111u8, 116u8, 111u8, 80u8, 1u8, + 90u8, 44u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 103u8, 111u8, + 108u8, 97u8, 110u8, 103u8, 46u8, 111u8, 114u8, 103u8, 47u8, 112u8, 114u8, + 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 47u8, 116u8, 121u8, 112u8, 101u8, + 115u8, 47u8, 107u8, 110u8, 111u8, 119u8, 110u8, 47u8, 97u8, 110u8, 121u8, + 112u8, 98u8, 162u8, 2u8, 3u8, 71u8, 80u8, 66u8, 170u8, 2u8, 30u8, 71u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 80u8, 114u8, 111u8, 116u8, 111u8, + 98u8, 117u8, 102u8, 46u8, 87u8, 101u8, 108u8, 108u8, 75u8, 110u8, 111u8, + 119u8, 110u8, 84u8, 121u8, 112u8, 101u8, 115u8, 74u8, 221u8, 44u8, 10u8, 7u8, + 18u8, 5u8, 30u8, 0u8, 161u8, 1u8, 1u8, 10u8, 204u8, 12u8, 10u8, 1u8, 12u8, + 18u8, 3u8, 30u8, 0u8, 18u8, 50u8, 193u8, 12u8, 32u8, 80u8, 114u8, 111u8, + 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, 66u8, 117u8, 102u8, 102u8, 101u8, + 114u8, 115u8, 32u8, 45u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 39u8, 115u8, 32u8, 100u8, 97u8, 116u8, 97u8, 32u8, 105u8, 110u8, 116u8, + 101u8, 114u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, 32u8, 102u8, 111u8, + 114u8, 109u8, 97u8, 116u8, 10u8, 32u8, 67u8, 111u8, 112u8, 121u8, 114u8, + 105u8, 103u8, 104u8, 116u8, 32u8, 50u8, 48u8, 48u8, 56u8, 32u8, 71u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 32u8, 65u8, + 108u8, 108u8, 32u8, 114u8, 105u8, 103u8, 104u8, 116u8, 115u8, 32u8, 114u8, + 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, 46u8, 10u8, 32u8, 104u8, + 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, 100u8, 101u8, 118u8, 101u8, + 108u8, 111u8, 112u8, 101u8, 114u8, 115u8, 46u8, 103u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 46u8, 99u8, 111u8, 109u8, 47u8, 112u8, 114u8, 111u8, 116u8, + 111u8, 99u8, 111u8, 108u8, 45u8, 98u8, 117u8, 102u8, 102u8, 101u8, 114u8, + 115u8, 47u8, 10u8, 10u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, + 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 32u8, 97u8, 110u8, + 100u8, 32u8, 117u8, 115u8, 101u8, 32u8, 105u8, 110u8, 32u8, 115u8, 111u8, + 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 110u8, 100u8, 32u8, 98u8, 105u8, + 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, 109u8, 115u8, 44u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 111u8, 114u8, 32u8, 119u8, 105u8, + 116u8, 104u8, 111u8, 117u8, 116u8, 10u8, 32u8, 109u8, 111u8, 100u8, 105u8, + 102u8, 105u8, 99u8, 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, 97u8, + 114u8, 101u8, 32u8, 112u8, 101u8, 114u8, 109u8, 105u8, 116u8, 116u8, 101u8, + 100u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, + 116u8, 104u8, 97u8, 116u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 111u8, + 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 99u8, 111u8, 110u8, + 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 97u8, 114u8, 101u8, + 10u8, 32u8, 109u8, 101u8, 116u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 111u8, 102u8, 32u8, + 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 99u8, 111u8, 100u8, 101u8, + 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 116u8, 97u8, 105u8, + 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 111u8, 118u8, 101u8, + 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, 116u8, 10u8, + 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, 44u8, 32u8, 116u8, 104u8, + 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, 102u8, 32u8, + 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, + 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 111u8, 108u8, + 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 100u8, 105u8, 115u8, 99u8, + 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 46u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 105u8, 110u8, 32u8, + 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, 109u8, + 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 112u8, 114u8, 111u8, + 100u8, 117u8, 99u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, + 111u8, 118u8, 101u8, 10u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, 105u8, + 103u8, 104u8, 116u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, 44u8, + 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, + 111u8, 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, + 110u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 100u8, + 105u8, 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 10u8, 32u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 100u8, 111u8, 99u8, 117u8, + 109u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 97u8, + 110u8, 100u8, 47u8, 111u8, 114u8, 32u8, 111u8, 116u8, 104u8, 101u8, 114u8, + 32u8, 109u8, 97u8, 116u8, 101u8, 114u8, 105u8, 97u8, 108u8, 115u8, 32u8, + 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 119u8, 105u8, + 116u8, 104u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 100u8, 105u8, 115u8, + 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 78u8, 101u8, 105u8, 116u8, 104u8, + 101u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, + 32u8, 111u8, 102u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 32u8, + 73u8, 110u8, 99u8, 46u8, 32u8, 110u8, 111u8, 114u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, 115u8, 32u8, 111u8, 102u8, 32u8, + 105u8, 116u8, 115u8, 10u8, 32u8, 99u8, 111u8, 110u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 111u8, 114u8, 115u8, 32u8, 109u8, 97u8, 121u8, 32u8, + 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, + 101u8, 110u8, 100u8, 111u8, 114u8, 115u8, 101u8, 32u8, 111u8, 114u8, 32u8, + 112u8, 114u8, 111u8, 109u8, 111u8, 116u8, 101u8, 32u8, 112u8, 114u8, 111u8, + 100u8, 117u8, 99u8, 116u8, 115u8, 32u8, 100u8, 101u8, 114u8, 105u8, 118u8, + 101u8, 100u8, 32u8, 102u8, 114u8, 111u8, 109u8, 10u8, 32u8, 116u8, 104u8, + 105u8, 115u8, 32u8, 115u8, 111u8, 102u8, 116u8, 119u8, 97u8, 114u8, 101u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 32u8, 115u8, 112u8, + 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 112u8, 114u8, 105u8, 111u8, + 114u8, 32u8, 119u8, 114u8, 105u8, 116u8, 116u8, 101u8, 110u8, 32u8, 112u8, + 101u8, 114u8, 109u8, 105u8, 115u8, 115u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 10u8, 32u8, 84u8, 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, + 82u8, 69u8, 32u8, 73u8, 83u8, 32u8, 80u8, 82u8, 79u8, 86u8, 73u8, 68u8, 69u8, + 68u8, 32u8, 66u8, 89u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, + 82u8, 73u8, 71u8, 72u8, 84u8, 32u8, 72u8, 79u8, 76u8, 68u8, 69u8, 82u8, 83u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, + 84u8, 79u8, 82u8, 83u8, 10u8, 32u8, 34u8, 65u8, 83u8, 32u8, 73u8, 83u8, 34u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 65u8, 78u8, 89u8, 32u8, 69u8, 88u8, 80u8, 82u8, + 69u8, 83u8, 83u8, 32u8, 79u8, 82u8, 32u8, 73u8, 77u8, 80u8, 76u8, 73u8, 69u8, + 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, 73u8, 69u8, 83u8, 44u8, + 32u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, 44u8, 32u8, 66u8, + 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, 76u8, 73u8, 77u8, 73u8, 84u8, + 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 84u8, 72u8, 69u8, 32u8, 73u8, 77u8, + 80u8, 76u8, 73u8, 69u8, 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, + 73u8, 69u8, 83u8, 32u8, 79u8, 70u8, 32u8, 77u8, 69u8, 82u8, 67u8, 72u8, 65u8, + 78u8, 84u8, 65u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 65u8, 78u8, 68u8, + 32u8, 70u8, 73u8, 84u8, 78u8, 69u8, 83u8, 83u8, 32u8, 70u8, 79u8, 82u8, 10u8, + 32u8, 65u8, 32u8, 80u8, 65u8, 82u8, 84u8, 73u8, 67u8, 85u8, 76u8, 65u8, 82u8, + 32u8, 80u8, 85u8, 82u8, 80u8, 79u8, 83u8, 69u8, 32u8, 65u8, 82u8, 69u8, 32u8, + 68u8, 73u8, 83u8, 67u8, 76u8, 65u8, 73u8, 77u8, 69u8, 68u8, 46u8, 32u8, 73u8, + 78u8, 32u8, 78u8, 79u8, 32u8, 69u8, 86u8, 69u8, 78u8, 84u8, 32u8, 83u8, 72u8, + 65u8, 76u8, 76u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, 82u8, + 73u8, 71u8, 72u8, 84u8, 10u8, 32u8, 79u8, 87u8, 78u8, 69u8, 82u8, 32u8, 79u8, + 82u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, 84u8, 79u8, 82u8, + 83u8, 32u8, 66u8, 69u8, 32u8, 76u8, 73u8, 65u8, 66u8, 76u8, 69u8, 32u8, 70u8, + 79u8, 82u8, 32u8, 65u8, 78u8, 89u8, 32u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, + 44u8, 32u8, 73u8, 78u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, 44u8, 32u8, 73u8, + 78u8, 67u8, 73u8, 68u8, 69u8, 78u8, 84u8, 65u8, 76u8, 44u8, 10u8, 32u8, 83u8, + 80u8, 69u8, 67u8, 73u8, 65u8, 76u8, 44u8, 32u8, 69u8, 88u8, 69u8, 77u8, 80u8, + 76u8, 65u8, 82u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 67u8, 79u8, 78u8, 83u8, + 69u8, 81u8, 85u8, 69u8, 78u8, 84u8, 73u8, 65u8, 76u8, 32u8, 68u8, 65u8, 77u8, + 65u8, 71u8, 69u8, 83u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, + 78u8, 71u8, 44u8, 32u8, 66u8, 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, + 76u8, 73u8, 77u8, 73u8, 84u8, 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 80u8, + 82u8, 79u8, 67u8, 85u8, 82u8, 69u8, 77u8, 69u8, 78u8, 84u8, 32u8, 79u8, 70u8, + 32u8, 83u8, 85u8, 66u8, 83u8, 84u8, 73u8, 84u8, 85u8, 84u8, 69u8, 32u8, 71u8, + 79u8, 79u8, 68u8, 83u8, 32u8, 79u8, 82u8, 32u8, 83u8, 69u8, 82u8, 86u8, 73u8, + 67u8, 69u8, 83u8, 59u8, 32u8, 76u8, 79u8, 83u8, 83u8, 32u8, 79u8, 70u8, 32u8, + 85u8, 83u8, 69u8, 44u8, 10u8, 32u8, 68u8, 65u8, 84u8, 65u8, 44u8, 32u8, 79u8, + 82u8, 32u8, 80u8, 82u8, 79u8, 70u8, 73u8, 84u8, 83u8, 59u8, 32u8, 79u8, 82u8, + 32u8, 66u8, 85u8, 83u8, 73u8, 78u8, 69u8, 83u8, 83u8, 32u8, 73u8, 78u8, 84u8, + 69u8, 82u8, 82u8, 85u8, 80u8, 84u8, 73u8, 79u8, 78u8, 41u8, 32u8, 72u8, 79u8, + 87u8, 69u8, 86u8, 69u8, 82u8, 32u8, 67u8, 65u8, 85u8, 83u8, 69u8, 68u8, 32u8, + 65u8, 78u8, 68u8, 32u8, 79u8, 78u8, 32u8, 65u8, 78u8, 89u8, 10u8, 32u8, 84u8, + 72u8, 69u8, 79u8, 82u8, 89u8, 32u8, 79u8, 70u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 87u8, 72u8, 69u8, 84u8, 72u8, 69u8, + 82u8, 32u8, 73u8, 78u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 65u8, 67u8, 84u8, + 44u8, 32u8, 83u8, 84u8, 82u8, 73u8, 67u8, 84u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 84u8, 79u8, 82u8, + 84u8, 10u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, + 32u8, 78u8, 69u8, 71u8, 76u8, 73u8, 71u8, 69u8, 78u8, 67u8, 69u8, 32u8, 79u8, + 82u8, 32u8, 79u8, 84u8, 72u8, 69u8, 82u8, 87u8, 73u8, 83u8, 69u8, 41u8, 32u8, + 65u8, 82u8, 73u8, 83u8, 73u8, 78u8, 71u8, 32u8, 73u8, 78u8, 32u8, 65u8, 78u8, + 89u8, 32u8, 87u8, 65u8, 89u8, 32u8, 79u8, 85u8, 84u8, 32u8, 79u8, 70u8, 32u8, + 84u8, 72u8, 69u8, 32u8, 85u8, 83u8, 69u8, 10u8, 32u8, 79u8, 70u8, 32u8, 84u8, + 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, 82u8, 69u8, 44u8, + 32u8, 69u8, 86u8, 69u8, 78u8, 32u8, 73u8, 70u8, 32u8, 65u8, 68u8, 86u8, 73u8, + 83u8, 69u8, 68u8, 32u8, 79u8, 70u8, 32u8, 84u8, 72u8, 69u8, 32u8, 80u8, 79u8, + 83u8, 83u8, 73u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 79u8, 70u8, 32u8, + 83u8, 85u8, 67u8, 72u8, 32u8, 68u8, 65u8, 77u8, 65u8, 71u8, 69u8, 46u8, 10u8, + 10u8, 8u8, 10u8, 1u8, 2u8, 18u8, 3u8, 32u8, 0u8, 24u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 34u8, 0u8, 67u8, 10u8, 9u8, 10u8, 2u8, 8u8, 11u8, 18u8, 3u8, + 34u8, 0u8, 67u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 35u8, 0u8, 44u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 1u8, 18u8, 3u8, 35u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 36u8, 0u8, 41u8, 10u8, 9u8, 10u8, 2u8, 8u8, 8u8, 18u8, 3u8, + 36u8, 0u8, 41u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 37u8, 0u8, 34u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 10u8, 18u8, 3u8, 37u8, 0u8, 34u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 38u8, 0u8, 33u8, 10u8, 9u8, 10u8, 2u8, 8u8, 36u8, 18u8, 3u8, + 38u8, 0u8, 33u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 39u8, 0u8, 59u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 37u8, 18u8, 3u8, 39u8, 0u8, 59u8, 10u8, 252u8, 17u8, + 10u8, 2u8, 4u8, 0u8, 18u8, 5u8, 127u8, 0u8, 161u8, 1u8, 1u8, 26u8, 238u8, + 17u8, 32u8, 96u8, 65u8, 110u8, 121u8, 96u8, 32u8, 99u8, 111u8, 110u8, 116u8, + 97u8, 105u8, 110u8, 115u8, 32u8, 97u8, 110u8, 32u8, 97u8, 114u8, 98u8, 105u8, + 116u8, 114u8, 97u8, 114u8, 121u8, 32u8, 115u8, 101u8, 114u8, 105u8, 97u8, + 108u8, 105u8, 122u8, 101u8, 100u8, 32u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 99u8, 111u8, 108u8, 32u8, 98u8, 117u8, 102u8, 102u8, 101u8, 114u8, 32u8, + 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 97u8, 108u8, 111u8, + 110u8, 103u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 97u8, 10u8, 32u8, 85u8, + 82u8, 76u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 100u8, 101u8, 115u8, 99u8, + 114u8, 105u8, 98u8, 101u8, 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, 116u8, + 121u8, 112u8, 101u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 115u8, 101u8, 114u8, 105u8, 97u8, 108u8, 105u8, 122u8, 101u8, 100u8, 32u8, + 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 46u8, 10u8, 10u8, 32u8, 80u8, + 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 32u8, 108u8, 105u8, 98u8, + 114u8, 97u8, 114u8, 121u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, + 101u8, 115u8, 32u8, 115u8, 117u8, 112u8, 112u8, 111u8, 114u8, 116u8, 32u8, + 116u8, 111u8, 32u8, 112u8, 97u8, 99u8, 107u8, 47u8, 117u8, 110u8, 112u8, + 97u8, 99u8, 107u8, 32u8, 65u8, 110u8, 121u8, 32u8, 118u8, 97u8, 108u8, 117u8, + 101u8, 115u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, + 111u8, 114u8, 109u8, 10u8, 32u8, 111u8, 102u8, 32u8, 117u8, 116u8, 105u8, + 108u8, 105u8, 116u8, 121u8, 32u8, 102u8, 117u8, 110u8, 99u8, 116u8, 105u8, + 111u8, 110u8, 115u8, 32u8, 111u8, 114u8, 32u8, 97u8, 100u8, 100u8, 105u8, + 116u8, 105u8, 111u8, 110u8, 97u8, 108u8, 32u8, 103u8, 101u8, 110u8, 101u8, + 114u8, 97u8, 116u8, 101u8, 100u8, 32u8, 109u8, 101u8, 116u8, 104u8, 111u8, + 100u8, 115u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 65u8, + 110u8, 121u8, 32u8, 116u8, 121u8, 112u8, 101u8, 46u8, 10u8, 10u8, 32u8, 69u8, + 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 49u8, 58u8, 32u8, 80u8, 97u8, + 99u8, 107u8, 32u8, 97u8, 110u8, 100u8, 32u8, 117u8, 110u8, 112u8, 97u8, 99u8, + 107u8, 32u8, 97u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 105u8, 110u8, 32u8, 67u8, 43u8, 43u8, 46u8, 10u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 70u8, 111u8, 111u8, 32u8, 102u8, 111u8, 111u8, 32u8, 61u8, + 32u8, 46u8, 46u8, 46u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 65u8, + 110u8, 121u8, 32u8, 97u8, 110u8, 121u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 97u8, 110u8, 121u8, 46u8, 80u8, 97u8, 99u8, 107u8, 70u8, 114u8, 111u8, + 109u8, 40u8, 102u8, 111u8, 111u8, 41u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 105u8, 102u8, + 32u8, 40u8, 97u8, 110u8, 121u8, 46u8, 85u8, 110u8, 112u8, 97u8, 99u8, 107u8, + 84u8, 111u8, 40u8, 38u8, 102u8, 111u8, 111u8, 41u8, 41u8, 32u8, 123u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, + 108u8, 101u8, 32u8, 50u8, 58u8, 32u8, 80u8, 97u8, 99u8, 107u8, 32u8, 97u8, + 110u8, 100u8, 32u8, 117u8, 110u8, 112u8, 97u8, 99u8, 107u8, 32u8, 97u8, 32u8, + 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 105u8, 110u8, 32u8, + 74u8, 97u8, 118u8, 97u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 70u8, 111u8, 111u8, 32u8, 102u8, 111u8, 111u8, 32u8, 61u8, 32u8, 46u8, 46u8, + 46u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 65u8, 110u8, 121u8, 32u8, + 97u8, 110u8, 121u8, 32u8, 61u8, 32u8, 65u8, 110u8, 121u8, 46u8, 112u8, 97u8, + 99u8, 107u8, 40u8, 102u8, 111u8, 111u8, 41u8, 59u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 105u8, + 102u8, 32u8, 40u8, 97u8, 110u8, 121u8, 46u8, 105u8, 115u8, 40u8, 70u8, 111u8, + 111u8, 46u8, 99u8, 108u8, 97u8, 115u8, 115u8, 41u8, 41u8, 32u8, 123u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 102u8, 111u8, 111u8, 32u8, 61u8, + 32u8, 97u8, 110u8, 121u8, 46u8, 117u8, 110u8, 112u8, 97u8, 99u8, 107u8, 40u8, + 70u8, 111u8, 111u8, 46u8, 99u8, 108u8, 97u8, 115u8, 115u8, 41u8, 59u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 47u8, 47u8, 32u8, 111u8, 114u8, 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 105u8, 102u8, 32u8, 40u8, 97u8, 110u8, 121u8, 46u8, 105u8, + 115u8, 83u8, 97u8, 109u8, 101u8, 84u8, 121u8, 112u8, 101u8, 65u8, 115u8, + 40u8, 70u8, 111u8, 111u8, 46u8, 103u8, 101u8, 116u8, 68u8, 101u8, 102u8, + 97u8, 117u8, 108u8, 116u8, 73u8, 110u8, 115u8, 116u8, 97u8, 110u8, 99u8, + 101u8, 40u8, 41u8, 41u8, 41u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 102u8, 111u8, 111u8, 32u8, 61u8, 32u8, 97u8, 110u8, 121u8, + 46u8, 117u8, 110u8, 112u8, 97u8, 99u8, 107u8, 40u8, 70u8, 111u8, 111u8, 46u8, + 103u8, 101u8, 116u8, 68u8, 101u8, 102u8, 97u8, 117u8, 108u8, 116u8, 73u8, + 110u8, 115u8, 116u8, 97u8, 110u8, 99u8, 101u8, 40u8, 41u8, 41u8, 59u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 32u8, 69u8, 120u8, + 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 51u8, 58u8, 32u8, 80u8, 97u8, 99u8, + 107u8, 32u8, 97u8, 110u8, 100u8, 32u8, 117u8, 110u8, 112u8, 97u8, 99u8, + 107u8, 32u8, 97u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 105u8, 110u8, 32u8, 80u8, 121u8, 116u8, 104u8, 111u8, 110u8, 46u8, + 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 102u8, 111u8, 111u8, 32u8, 61u8, + 32u8, 70u8, 111u8, 111u8, 40u8, 46u8, 46u8, 46u8, 41u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 97u8, 110u8, 121u8, 32u8, 61u8, 32u8, 65u8, 110u8, 121u8, + 40u8, 41u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 97u8, 110u8, 121u8, 46u8, + 80u8, 97u8, 99u8, 107u8, 40u8, 102u8, 111u8, 111u8, 41u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 105u8, 102u8, 32u8, 97u8, 110u8, 121u8, 46u8, 73u8, 115u8, 40u8, 70u8, 111u8, + 111u8, 46u8, 68u8, 69u8, 83u8, 67u8, 82u8, 73u8, 80u8, 84u8, 79u8, 82u8, + 41u8, 58u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 97u8, 110u8, + 121u8, 46u8, 85u8, 110u8, 112u8, 97u8, 99u8, 107u8, 40u8, 102u8, 111u8, + 111u8, 41u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 46u8, 46u8, + 46u8, 10u8, 10u8, 32u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, + 32u8, 52u8, 58u8, 32u8, 80u8, 97u8, 99u8, 107u8, 32u8, 97u8, 110u8, 100u8, + 32u8, 117u8, 110u8, 112u8, 97u8, 99u8, 107u8, 32u8, 97u8, 32u8, 109u8, 101u8, + 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 105u8, 110u8, 32u8, 71u8, 111u8, + 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 102u8, 111u8, 111u8, 32u8, + 58u8, 61u8, 32u8, 38u8, 112u8, 98u8, 46u8, 70u8, 111u8, 111u8, 123u8, 46u8, + 46u8, 46u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 97u8, 110u8, + 121u8, 44u8, 32u8, 101u8, 114u8, 114u8, 32u8, 58u8, 61u8, 32u8, 97u8, 110u8, + 121u8, 112u8, 98u8, 46u8, 78u8, 101u8, 119u8, 40u8, 102u8, 111u8, 111u8, + 41u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 105u8, 102u8, 32u8, 101u8, + 114u8, 114u8, 32u8, 33u8, 61u8, 32u8, 110u8, 105u8, 108u8, 32u8, 123u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 102u8, + 111u8, 111u8, 32u8, 58u8, 61u8, 32u8, 38u8, 112u8, 98u8, 46u8, 70u8, 111u8, + 111u8, 123u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 105u8, 102u8, + 32u8, 101u8, 114u8, 114u8, 32u8, 58u8, 61u8, 32u8, 97u8, 110u8, 121u8, 46u8, + 85u8, 110u8, 109u8, 97u8, 114u8, 115u8, 104u8, 97u8, 108u8, 84u8, 111u8, + 40u8, 102u8, 111u8, 111u8, 41u8, 59u8, 32u8, 101u8, 114u8, 114u8, 32u8, 33u8, + 61u8, 32u8, 110u8, 105u8, 108u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 46u8, 46u8, 46u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 125u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 112u8, 97u8, 99u8, + 107u8, 32u8, 109u8, 101u8, 116u8, 104u8, 111u8, 100u8, 115u8, 32u8, 112u8, + 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 98u8, 121u8, 32u8, + 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 32u8, 108u8, 105u8, + 98u8, 114u8, 97u8, 114u8, 121u8, 32u8, 119u8, 105u8, 108u8, 108u8, 32u8, + 98u8, 121u8, 32u8, 100u8, 101u8, 102u8, 97u8, 117u8, 108u8, 116u8, 32u8, + 117u8, 115u8, 101u8, 10u8, 32u8, 39u8, 116u8, 121u8, 112u8, 101u8, 46u8, + 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 97u8, 112u8, 105u8, 115u8, 46u8, + 99u8, 111u8, 109u8, 47u8, 102u8, 117u8, 108u8, 108u8, 46u8, 116u8, 121u8, + 112u8, 101u8, 46u8, 110u8, 97u8, 109u8, 101u8, 39u8, 32u8, 97u8, 115u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 85u8, 82u8, + 76u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, 117u8, + 110u8, 112u8, 97u8, 99u8, 107u8, 10u8, 32u8, 109u8, 101u8, 116u8, 104u8, + 111u8, 100u8, 115u8, 32u8, 111u8, 110u8, 108u8, 121u8, 32u8, 117u8, 115u8, + 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 117u8, 108u8, 108u8, 121u8, + 32u8, 113u8, 117u8, 97u8, 108u8, 105u8, 102u8, 105u8, 101u8, 100u8, 32u8, + 116u8, 121u8, 112u8, 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, 32u8, 97u8, + 102u8, 116u8, 101u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 108u8, 97u8, + 115u8, 116u8, 32u8, 39u8, 47u8, 39u8, 10u8, 32u8, 105u8, 110u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 85u8, 82u8, 76u8, 44u8, + 32u8, 102u8, 111u8, 114u8, 32u8, 101u8, 120u8, 97u8, 109u8, 112u8, 108u8, + 101u8, 32u8, 34u8, 102u8, 111u8, 111u8, 46u8, 98u8, 97u8, 114u8, 46u8, 99u8, + 111u8, 109u8, 47u8, 120u8, 47u8, 121u8, 46u8, 122u8, 34u8, 32u8, 119u8, + 105u8, 108u8, 108u8, 32u8, 121u8, 105u8, 101u8, 108u8, 100u8, 32u8, 116u8, + 121u8, 112u8, 101u8, 10u8, 32u8, 110u8, 97u8, 109u8, 101u8, 32u8, 34u8, + 121u8, 46u8, 122u8, 34u8, 46u8, 10u8, 10u8, 32u8, 74u8, 83u8, 79u8, 78u8, + 10u8, 32u8, 61u8, 61u8, 61u8, 61u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, + 74u8, 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, + 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 111u8, 102u8, + 32u8, 97u8, 110u8, 32u8, 96u8, 65u8, 110u8, 121u8, 96u8, 32u8, 118u8, 97u8, + 108u8, 117u8, 101u8, 32u8, 117u8, 115u8, 101u8, 115u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 114u8, 101u8, 103u8, 117u8, 108u8, 97u8, 114u8, 10u8, 32u8, + 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 100u8, 101u8, 115u8, 101u8, 114u8, 105u8, 97u8, 108u8, 105u8, 122u8, 101u8, + 100u8, 44u8, 32u8, 101u8, 109u8, 98u8, 101u8, 100u8, 100u8, 101u8, 100u8, + 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 44u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 97u8, 110u8, 10u8, 32u8, 97u8, 100u8, 100u8, + 105u8, 116u8, 105u8, 111u8, 110u8, 97u8, 108u8, 32u8, 102u8, 105u8, 101u8, + 108u8, 100u8, 32u8, 96u8, 64u8, 116u8, 121u8, 112u8, 101u8, 96u8, 32u8, + 119u8, 104u8, 105u8, 99u8, 104u8, 32u8, 99u8, 111u8, 110u8, 116u8, 97u8, + 105u8, 110u8, 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, 116u8, 121u8, 112u8, + 101u8, 32u8, 85u8, 82u8, 76u8, 46u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, + 108u8, 101u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 112u8, 97u8, + 99u8, 107u8, 97u8, 103u8, 101u8, 32u8, 103u8, 111u8, 111u8, 103u8, 108u8, + 101u8, 46u8, 112u8, 114u8, 111u8, 102u8, 105u8, 108u8, 101u8, 59u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 80u8, 101u8, 114u8, 115u8, 111u8, 110u8, 32u8, 123u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 32u8, + 102u8, 105u8, 114u8, 115u8, 116u8, 95u8, 110u8, 97u8, 109u8, 101u8, 32u8, + 61u8, 32u8, 49u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 32u8, 108u8, 97u8, 115u8, 116u8, + 95u8, 110u8, 97u8, 109u8, 101u8, 32u8, 61u8, 32u8, 50u8, 59u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 34u8, 64u8, 116u8, + 121u8, 112u8, 101u8, 34u8, 58u8, 32u8, 34u8, 116u8, 121u8, 112u8, 101u8, + 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 97u8, 112u8, 105u8, 115u8, + 46u8, 99u8, 111u8, 109u8, 47u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 46u8, 112u8, 114u8, 111u8, 102u8, 105u8, 108u8, 101u8, 46u8, 80u8, 101u8, + 114u8, 115u8, 111u8, 110u8, 34u8, 44u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 34u8, 102u8, 105u8, 114u8, 115u8, 116u8, 78u8, 97u8, 109u8, + 101u8, 34u8, 58u8, 32u8, 60u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, + 62u8, 44u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 34u8, 108u8, + 97u8, 115u8, 116u8, 78u8, 97u8, 109u8, 101u8, 34u8, 58u8, 32u8, 60u8, 115u8, + 116u8, 114u8, 105u8, 110u8, 103u8, 62u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 125u8, 10u8, 10u8, 32u8, 73u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 101u8, + 109u8, 98u8, 101u8, 100u8, 100u8, 101u8, 100u8, 32u8, 109u8, 101u8, 115u8, + 115u8, 97u8, 103u8, 101u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 105u8, + 115u8, 32u8, 119u8, 101u8, 108u8, 108u8, 45u8, 107u8, 110u8, 111u8, 119u8, + 110u8, 32u8, 97u8, 110u8, 100u8, 32u8, 104u8, 97u8, 115u8, 32u8, 97u8, 32u8, + 99u8, 117u8, 115u8, 116u8, 111u8, 109u8, 32u8, 74u8, 83u8, 79u8, 78u8, 10u8, + 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, + 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, + 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 32u8, 119u8, 105u8, 108u8, 108u8, 32u8, 98u8, 101u8, + 32u8, 101u8, 109u8, 98u8, 101u8, 100u8, 100u8, 101u8, 100u8, 32u8, 97u8, + 100u8, 100u8, 105u8, 110u8, 103u8, 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, + 108u8, 100u8, 10u8, 32u8, 96u8, 118u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, + 119u8, 104u8, 105u8, 99u8, 104u8, 32u8, 104u8, 111u8, 108u8, 100u8, 115u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 99u8, 117u8, 115u8, 116u8, 111u8, 109u8, + 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 105u8, 110u8, 32u8, 97u8, 100u8, 100u8, + 105u8, 116u8, 105u8, 111u8, 110u8, 32u8, 116u8, 111u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 96u8, 64u8, 116u8, 121u8, 112u8, 101u8, 96u8, 10u8, 32u8, 102u8, + 105u8, 101u8, 108u8, 100u8, 46u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, + 108u8, 101u8, 32u8, 40u8, 102u8, 111u8, 114u8, 32u8, 109u8, 101u8, 115u8, + 115u8, 97u8, 103u8, 101u8, 32u8, 91u8, 103u8, 111u8, 111u8, 103u8, 108u8, + 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, + 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 93u8, 91u8, 93u8, 41u8, + 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 123u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 34u8, 64u8, 116u8, 121u8, 112u8, 101u8, 34u8, + 58u8, 32u8, 34u8, 116u8, 121u8, 112u8, 101u8, 46u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 97u8, 112u8, 105u8, 115u8, 46u8, 99u8, 111u8, 109u8, + 47u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 68u8, 117u8, 114u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 34u8, 44u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 34u8, 118u8, 97u8, 108u8, 117u8, 101u8, 34u8, 58u8, 32u8, 34u8, 49u8, + 46u8, 50u8, 49u8, 50u8, 115u8, 34u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 125u8, 10u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 0u8, 1u8, 18u8, 3u8, 127u8, + 8u8, 11u8, 10u8, 188u8, 11u8, 10u8, 4u8, 4u8, 0u8, 2u8, 0u8, 18u8, 4u8, + 157u8, 1u8, 2u8, 22u8, 26u8, 173u8, 11u8, 32u8, 65u8, 32u8, 85u8, 82u8, 76u8, + 47u8, 114u8, 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 110u8, + 97u8, 109u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 117u8, 110u8, + 105u8, 113u8, 117u8, 101u8, 108u8, 121u8, 32u8, 105u8, 100u8, 101u8, 110u8, + 116u8, 105u8, 102u8, 105u8, 101u8, 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 116u8, 121u8, 112u8, 101u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 115u8, 101u8, 114u8, 105u8, 97u8, 108u8, 105u8, 122u8, 101u8, 100u8, + 10u8, 32u8, 112u8, 114u8, 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, + 98u8, 117u8, 102u8, 102u8, 101u8, 114u8, 32u8, 109u8, 101u8, 115u8, 115u8, + 97u8, 103u8, 101u8, 46u8, 32u8, 84u8, 104u8, 105u8, 115u8, 32u8, 115u8, + 116u8, 114u8, 105u8, 110u8, 103u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, + 99u8, 111u8, 110u8, 116u8, 97u8, 105u8, 110u8, 32u8, 97u8, 116u8, 32u8, + 108u8, 101u8, 97u8, 115u8, 116u8, 10u8, 32u8, 111u8, 110u8, 101u8, 32u8, + 34u8, 47u8, 34u8, 32u8, 99u8, 104u8, 97u8, 114u8, 97u8, 99u8, 116u8, 101u8, + 114u8, 46u8, 32u8, 84u8, 104u8, 101u8, 32u8, 108u8, 97u8, 115u8, 116u8, 32u8, + 115u8, 101u8, 103u8, 109u8, 101u8, 110u8, 116u8, 32u8, 111u8, 102u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 85u8, 82u8, 76u8, 39u8, 115u8, 32u8, 112u8, 97u8, + 116u8, 104u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 112u8, + 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 10u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 117u8, 108u8, 108u8, 121u8, 32u8, 113u8, 117u8, 97u8, 108u8, + 105u8, 102u8, 105u8, 101u8, 100u8, 32u8, 110u8, 97u8, 109u8, 101u8, 32u8, + 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 116u8, 121u8, 112u8, 101u8, + 32u8, 40u8, 97u8, 115u8, 32u8, 105u8, 110u8, 10u8, 32u8, 96u8, 112u8, 97u8, + 116u8, 104u8, 47u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, + 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 68u8, 117u8, 114u8, + 97u8, 116u8, 105u8, 111u8, 110u8, 96u8, 41u8, 46u8, 32u8, 84u8, 104u8, 101u8, + 32u8, 110u8, 97u8, 109u8, 101u8, 32u8, 115u8, 104u8, 111u8, 117u8, 108u8, + 100u8, 32u8, 98u8, 101u8, 32u8, 105u8, 110u8, 32u8, 97u8, 32u8, 99u8, 97u8, + 110u8, 111u8, 110u8, 105u8, 99u8, 97u8, 108u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 10u8, 32u8, 40u8, 101u8, 46u8, 103u8, 46u8, 44u8, 32u8, 108u8, 101u8, + 97u8, 100u8, 105u8, 110u8, 103u8, 32u8, 34u8, 46u8, 34u8, 32u8, 105u8, 115u8, + 32u8, 110u8, 111u8, 116u8, 32u8, 97u8, 99u8, 99u8, 101u8, 112u8, 116u8, + 101u8, 100u8, 41u8, 46u8, 10u8, 10u8, 32u8, 73u8, 110u8, 32u8, 112u8, 114u8, + 97u8, 99u8, 116u8, 105u8, 99u8, 101u8, 44u8, 32u8, 116u8, 101u8, 97u8, 109u8, + 115u8, 32u8, 117u8, 115u8, 117u8, 97u8, 108u8, 108u8, 121u8, 32u8, 112u8, + 114u8, 101u8, 99u8, 111u8, 109u8, 112u8, 105u8, 108u8, 101u8, 32u8, 105u8, + 110u8, 116u8, 111u8, 32u8, 116u8, 104u8, 101u8, 32u8, 98u8, 105u8, 110u8, + 97u8, 114u8, 121u8, 32u8, 97u8, 108u8, 108u8, 32u8, 116u8, 121u8, 112u8, + 101u8, 115u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 116u8, 104u8, 101u8, + 121u8, 10u8, 32u8, 101u8, 120u8, 112u8, 101u8, 99u8, 116u8, 32u8, 105u8, + 116u8, 32u8, 116u8, 111u8, 32u8, 117u8, 115u8, 101u8, 32u8, 105u8, 110u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 99u8, 111u8, 110u8, 116u8, 101u8, 120u8, + 116u8, 32u8, 111u8, 102u8, 32u8, 65u8, 110u8, 121u8, 46u8, 32u8, 72u8, 111u8, + 119u8, 101u8, 118u8, 101u8, 114u8, 44u8, 32u8, 102u8, 111u8, 114u8, 32u8, + 85u8, 82u8, 76u8, 115u8, 32u8, 119u8, 104u8, 105u8, 99u8, 104u8, 32u8, 117u8, + 115u8, 101u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 115u8, 99u8, 104u8, + 101u8, 109u8, 101u8, 32u8, 96u8, 104u8, 116u8, 116u8, 112u8, 96u8, 44u8, + 32u8, 96u8, 104u8, 116u8, 116u8, 112u8, 115u8, 96u8, 44u8, 32u8, 111u8, + 114u8, 32u8, 110u8, 111u8, 32u8, 115u8, 99u8, 104u8, 101u8, 109u8, 101u8, + 44u8, 32u8, 111u8, 110u8, 101u8, 32u8, 99u8, 97u8, 110u8, 32u8, 111u8, 112u8, + 116u8, 105u8, 111u8, 110u8, 97u8, 108u8, 108u8, 121u8, 32u8, 115u8, 101u8, + 116u8, 32u8, 117u8, 112u8, 32u8, 97u8, 32u8, 116u8, 121u8, 112u8, 101u8, + 10u8, 32u8, 115u8, 101u8, 114u8, 118u8, 101u8, 114u8, 32u8, 116u8, 104u8, + 97u8, 116u8, 32u8, 109u8, 97u8, 112u8, 115u8, 32u8, 116u8, 121u8, 112u8, + 101u8, 32u8, 85u8, 82u8, 76u8, 115u8, 32u8, 116u8, 111u8, 32u8, 109u8, 101u8, + 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 100u8, 101u8, 102u8, 105u8, 110u8, + 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 97u8, 115u8, 32u8, 102u8, + 111u8, 108u8, 108u8, 111u8, 119u8, 115u8, 58u8, 10u8, 10u8, 32u8, 42u8, 32u8, + 73u8, 102u8, 32u8, 110u8, 111u8, 32u8, 115u8, 99u8, 104u8, 101u8, 109u8, + 101u8, 32u8, 105u8, 115u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, + 101u8, 100u8, 44u8, 32u8, 96u8, 104u8, 116u8, 116u8, 112u8, 115u8, 96u8, + 32u8, 105u8, 115u8, 32u8, 97u8, 115u8, 115u8, 117u8, 109u8, 101u8, 100u8, + 46u8, 10u8, 32u8, 42u8, 32u8, 65u8, 110u8, 32u8, 72u8, 84u8, 84u8, 80u8, + 32u8, 71u8, 69u8, 84u8, 32u8, 111u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 85u8, 82u8, 76u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 121u8, 105u8, + 101u8, 108u8, 100u8, 32u8, 97u8, 32u8, 91u8, 103u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, + 46u8, 84u8, 121u8, 112u8, 101u8, 93u8, 91u8, 93u8, 10u8, 32u8, 32u8, 32u8, + 118u8, 97u8, 108u8, 117u8, 101u8, 32u8, 105u8, 110u8, 32u8, 98u8, 105u8, + 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, + 44u8, 32u8, 111u8, 114u8, 32u8, 112u8, 114u8, 111u8, 100u8, 117u8, 99u8, + 101u8, 32u8, 97u8, 110u8, 32u8, 101u8, 114u8, 114u8, 111u8, 114u8, 46u8, + 10u8, 32u8, 42u8, 32u8, 65u8, 112u8, 112u8, 108u8, 105u8, 99u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 115u8, 32u8, 97u8, 114u8, 101u8, 32u8, 97u8, 108u8, + 108u8, 111u8, 119u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, 99u8, 97u8, + 99u8, 104u8, 101u8, 32u8, 108u8, 111u8, 111u8, 107u8, 117u8, 112u8, 32u8, + 114u8, 101u8, 115u8, 117u8, 108u8, 116u8, 115u8, 32u8, 98u8, 97u8, 115u8, + 101u8, 100u8, 32u8, 111u8, 110u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, + 32u8, 32u8, 85u8, 82u8, 76u8, 44u8, 32u8, 111u8, 114u8, 32u8, 104u8, 97u8, + 118u8, 101u8, 32u8, 116u8, 104u8, 101u8, 109u8, 32u8, 112u8, 114u8, 101u8, + 99u8, 111u8, 109u8, 112u8, 105u8, 108u8, 101u8, 100u8, 32u8, 105u8, 110u8, + 116u8, 111u8, 32u8, 97u8, 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, + 116u8, 111u8, 32u8, 97u8, 118u8, 111u8, 105u8, 100u8, 32u8, 97u8, 110u8, + 121u8, 10u8, 32u8, 32u8, 32u8, 108u8, 111u8, 111u8, 107u8, 117u8, 112u8, + 46u8, 32u8, 84u8, 104u8, 101u8, 114u8, 101u8, 102u8, 111u8, 114u8, 101u8, + 44u8, 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 99u8, 111u8, 109u8, + 112u8, 97u8, 116u8, 105u8, 98u8, 105u8, 108u8, 105u8, 116u8, 121u8, 32u8, + 110u8, 101u8, 101u8, 100u8, 115u8, 32u8, 116u8, 111u8, 32u8, 98u8, 101u8, + 32u8, 112u8, 114u8, 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, 10u8, + 32u8, 32u8, 32u8, 111u8, 110u8, 32u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, + 115u8, 32u8, 116u8, 111u8, 32u8, 116u8, 121u8, 112u8, 101u8, 115u8, 46u8, + 32u8, 40u8, 85u8, 115u8, 101u8, 32u8, 118u8, 101u8, 114u8, 115u8, 105u8, + 111u8, 110u8, 101u8, 100u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 110u8, + 97u8, 109u8, 101u8, 115u8, 32u8, 116u8, 111u8, 32u8, 109u8, 97u8, 110u8, + 97u8, 103u8, 101u8, 10u8, 32u8, 32u8, 32u8, 98u8, 114u8, 101u8, 97u8, 107u8, + 105u8, 110u8, 103u8, 32u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, 115u8, + 46u8, 41u8, 10u8, 10u8, 32u8, 78u8, 111u8, 116u8, 101u8, 58u8, 32u8, 116u8, + 104u8, 105u8, 115u8, 32u8, 102u8, 117u8, 110u8, 99u8, 116u8, 105u8, 111u8, + 110u8, 97u8, 108u8, 105u8, 116u8, 121u8, 32u8, 105u8, 115u8, 32u8, 110u8, + 111u8, 116u8, 32u8, 99u8, 117u8, 114u8, 114u8, 101u8, 110u8, 116u8, 108u8, + 121u8, 32u8, 97u8, 118u8, 97u8, 105u8, 108u8, 97u8, 98u8, 108u8, 101u8, 32u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 111u8, 102u8, 102u8, 105u8, + 99u8, 105u8, 97u8, 108u8, 10u8, 32u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 98u8, 117u8, 102u8, 32u8, 114u8, 101u8, 108u8, 101u8, 97u8, 115u8, 101u8, + 44u8, 32u8, 97u8, 110u8, 100u8, 32u8, 105u8, 116u8, 32u8, 105u8, 115u8, 32u8, + 110u8, 111u8, 116u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 102u8, 111u8, + 114u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 85u8, 82u8, 76u8, 115u8, 32u8, + 98u8, 101u8, 103u8, 105u8, 110u8, 110u8, 105u8, 110u8, 103u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 10u8, 32u8, 116u8, 121u8, 112u8, 101u8, 46u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 97u8, 112u8, 105u8, 115u8, 46u8, 99u8, + 111u8, 109u8, 46u8, 32u8, 65u8, 115u8, 32u8, 111u8, 102u8, 32u8, 77u8, 97u8, + 121u8, 32u8, 50u8, 48u8, 50u8, 51u8, 44u8, 32u8, 116u8, 104u8, 101u8, 114u8, + 101u8, 32u8, 97u8, 114u8, 101u8, 32u8, 110u8, 111u8, 32u8, 119u8, 105u8, + 100u8, 101u8, 108u8, 121u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 116u8, + 121u8, 112u8, 101u8, 32u8, 115u8, 101u8, 114u8, 118u8, 101u8, 114u8, 10u8, + 32u8, 105u8, 109u8, 112u8, 108u8, 101u8, 109u8, 101u8, 110u8, 116u8, 97u8, + 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 110u8, + 111u8, 32u8, 112u8, 108u8, 97u8, 110u8, 115u8, 32u8, 116u8, 111u8, 32u8, + 105u8, 109u8, 112u8, 108u8, 101u8, 109u8, 101u8, 110u8, 116u8, 32u8, 111u8, + 110u8, 101u8, 46u8, 10u8, 10u8, 32u8, 83u8, 99u8, 104u8, 101u8, 109u8, 101u8, + 115u8, 32u8, 111u8, 116u8, 104u8, 101u8, 114u8, 32u8, 116u8, 104u8, 97u8, + 110u8, 32u8, 96u8, 104u8, 116u8, 116u8, 112u8, 96u8, 44u8, 32u8, 96u8, 104u8, + 116u8, 116u8, 112u8, 115u8, 96u8, 32u8, 40u8, 111u8, 114u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 101u8, 109u8, 112u8, 116u8, 121u8, 32u8, 115u8, 99u8, + 104u8, 101u8, 109u8, 101u8, 41u8, 32u8, 109u8, 105u8, 103u8, 104u8, 116u8, + 32u8, 98u8, 101u8, 10u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 105u8, 109u8, 112u8, 108u8, 101u8, 109u8, 101u8, + 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 115u8, 112u8, 101u8, + 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 115u8, 101u8, 109u8, 97u8, 110u8, + 116u8, 105u8, 99u8, 115u8, 46u8, 10u8, 10u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, + 2u8, 0u8, 5u8, 18u8, 4u8, 157u8, 1u8, 2u8, 8u8, 10u8, 13u8, 10u8, 5u8, 4u8, + 0u8, 2u8, 0u8, 1u8, 18u8, 4u8, 157u8, 1u8, 9u8, 17u8, 10u8, 13u8, 10u8, 5u8, + 4u8, 0u8, 2u8, 0u8, 3u8, 18u8, 4u8, 157u8, 1u8, 20u8, 21u8, 10u8, 87u8, 10u8, + 4u8, 4u8, 0u8, 2u8, 1u8, 18u8, 4u8, 160u8, 1u8, 2u8, 18u8, 26u8, 73u8, 32u8, + 77u8, 117u8, 115u8, 116u8, 32u8, 98u8, 101u8, 32u8, 97u8, 32u8, 118u8, 97u8, + 108u8, 105u8, 100u8, 32u8, 115u8, 101u8, 114u8, 105u8, 97u8, 108u8, 105u8, + 122u8, 101u8, 100u8, 32u8, 112u8, 114u8, 111u8, 116u8, 111u8, 99u8, 111u8, + 108u8, 32u8, 98u8, 117u8, 102u8, 102u8, 101u8, 114u8, 32u8, 111u8, 102u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 111u8, 118u8, 101u8, 32u8, + 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 105u8, 101u8, 100u8, 32u8, 116u8, + 121u8, 112u8, 101u8, 46u8, 10u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, 1u8, + 5u8, 18u8, 4u8, 160u8, 1u8, 2u8, 7u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, + 1u8, 1u8, 18u8, 4u8, 160u8, 1u8, 8u8, 13u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, + 2u8, 1u8, 3u8, 18u8, 4u8, 160u8, 1u8, 16u8, 17u8, 98u8, 6u8, 112u8, 114u8, + 111u8, 116u8, 111u8, 51u8, 10u8, 215u8, 37u8, 10u8, 30u8, 103u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, + 117u8, 102u8, 47u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 18u8, 15u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 34u8, 58u8, 10u8, 8u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, + 110u8, 18u8, 24u8, 10u8, 7u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, + 24u8, 1u8, 32u8, 1u8, 40u8, 3u8, 82u8, 7u8, 115u8, 101u8, 99u8, 111u8, 110u8, + 100u8, 115u8, 18u8, 20u8, 10u8, 5u8, 110u8, 97u8, 110u8, 111u8, 115u8, 24u8, + 2u8, 32u8, 1u8, 40u8, 5u8, 82u8, 5u8, 110u8, 97u8, 110u8, 111u8, 115u8, 66u8, + 131u8, 1u8, 10u8, 19u8, 99u8, 111u8, 109u8, 46u8, 103u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, + 66u8, 13u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 80u8, + 114u8, 111u8, 116u8, 111u8, 80u8, 1u8, 90u8, 49u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 103u8, 111u8, 108u8, 97u8, 110u8, 103u8, 46u8, + 111u8, 114u8, 103u8, 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 47u8, 116u8, 121u8, 112u8, 101u8, 115u8, 47u8, 107u8, 110u8, 111u8, + 119u8, 110u8, 47u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 112u8, 98u8, 248u8, 1u8, 1u8, 162u8, 2u8, 3u8, 71u8, 80u8, 66u8, 170u8, 2u8, + 30u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 80u8, 114u8, 111u8, + 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 87u8, 101u8, 108u8, 108u8, 75u8, + 110u8, 111u8, 119u8, 110u8, 84u8, 121u8, 112u8, 101u8, 115u8, 74u8, 217u8, + 35u8, 10u8, 6u8, 18u8, 4u8, 30u8, 0u8, 114u8, 1u8, 10u8, 204u8, 12u8, 10u8, + 1u8, 12u8, 18u8, 3u8, 30u8, 0u8, 18u8, 50u8, 193u8, 12u8, 32u8, 80u8, 114u8, + 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, 66u8, 117u8, 102u8, 102u8, + 101u8, 114u8, 115u8, 32u8, 45u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, + 101u8, 39u8, 115u8, 32u8, 100u8, 97u8, 116u8, 97u8, 32u8, 105u8, 110u8, + 116u8, 101u8, 114u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, 32u8, 102u8, + 111u8, 114u8, 109u8, 97u8, 116u8, 10u8, 32u8, 67u8, 111u8, 112u8, 121u8, + 114u8, 105u8, 103u8, 104u8, 116u8, 32u8, 50u8, 48u8, 48u8, 56u8, 32u8, 71u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 32u8, + 65u8, 108u8, 108u8, 32u8, 114u8, 105u8, 103u8, 104u8, 116u8, 115u8, 32u8, + 114u8, 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, 46u8, 10u8, 32u8, + 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, 100u8, 101u8, 118u8, + 101u8, 108u8, 111u8, 112u8, 101u8, 114u8, 115u8, 46u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 99u8, 111u8, 109u8, 47u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 99u8, 111u8, 108u8, 45u8, 98u8, 117u8, 102u8, 102u8, 101u8, + 114u8, 115u8, 47u8, 10u8, 10u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, + 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 32u8, 97u8, + 110u8, 100u8, 32u8, 117u8, 115u8, 101u8, 32u8, 105u8, 110u8, 32u8, 115u8, + 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 110u8, 100u8, 32u8, 98u8, + 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, 109u8, 115u8, + 44u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 111u8, 114u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 10u8, 32u8, 109u8, 111u8, 100u8, + 105u8, 102u8, 105u8, 99u8, 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, + 97u8, 114u8, 101u8, 32u8, 112u8, 101u8, 114u8, 109u8, 105u8, 116u8, 116u8, + 101u8, 100u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, + 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, + 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 99u8, 111u8, + 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 97u8, 114u8, + 101u8, 10u8, 32u8, 109u8, 101u8, 116u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 111u8, 102u8, + 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 99u8, 111u8, 100u8, + 101u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 116u8, 97u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 111u8, 118u8, + 101u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, 116u8, + 10u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, 44u8, 32u8, 116u8, + 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, 102u8, + 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 111u8, + 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 100u8, 105u8, 115u8, + 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 46u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 105u8, 110u8, + 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 112u8, 114u8, + 111u8, 100u8, 117u8, 99u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, + 98u8, 111u8, 118u8, 101u8, 10u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, + 105u8, 103u8, 104u8, 116u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, + 44u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, + 32u8, 111u8, 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, + 111u8, 110u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, + 100u8, 105u8, 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 10u8, + 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 100u8, 111u8, 99u8, + 117u8, 109u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 97u8, 110u8, 100u8, 47u8, 111u8, 114u8, 32u8, 111u8, 116u8, 104u8, 101u8, + 114u8, 32u8, 109u8, 97u8, 116u8, 101u8, 114u8, 105u8, 97u8, 108u8, 115u8, + 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 100u8, 105u8, + 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 78u8, 101u8, 105u8, 116u8, + 104u8, 101u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 110u8, 97u8, 109u8, + 101u8, 32u8, 111u8, 102u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 110u8, 111u8, 114u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, 115u8, 32u8, 111u8, 102u8, 32u8, + 105u8, 116u8, 115u8, 10u8, 32u8, 99u8, 111u8, 110u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 111u8, 114u8, 115u8, 32u8, 109u8, 97u8, 121u8, 32u8, + 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, + 101u8, 110u8, 100u8, 111u8, 114u8, 115u8, 101u8, 32u8, 111u8, 114u8, 32u8, + 112u8, 114u8, 111u8, 109u8, 111u8, 116u8, 101u8, 32u8, 112u8, 114u8, 111u8, + 100u8, 117u8, 99u8, 116u8, 115u8, 32u8, 100u8, 101u8, 114u8, 105u8, 118u8, + 101u8, 100u8, 32u8, 102u8, 114u8, 111u8, 109u8, 10u8, 32u8, 116u8, 104u8, + 105u8, 115u8, 32u8, 115u8, 111u8, 102u8, 116u8, 119u8, 97u8, 114u8, 101u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 32u8, 115u8, 112u8, + 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 112u8, 114u8, 105u8, 111u8, + 114u8, 32u8, 119u8, 114u8, 105u8, 116u8, 116u8, 101u8, 110u8, 32u8, 112u8, + 101u8, 114u8, 109u8, 105u8, 115u8, 115u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 10u8, 32u8, 84u8, 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, + 82u8, 69u8, 32u8, 73u8, 83u8, 32u8, 80u8, 82u8, 79u8, 86u8, 73u8, 68u8, 69u8, + 68u8, 32u8, 66u8, 89u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, + 82u8, 73u8, 71u8, 72u8, 84u8, 32u8, 72u8, 79u8, 76u8, 68u8, 69u8, 82u8, 83u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, + 84u8, 79u8, 82u8, 83u8, 10u8, 32u8, 34u8, 65u8, 83u8, 32u8, 73u8, 83u8, 34u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 65u8, 78u8, 89u8, 32u8, 69u8, 88u8, 80u8, 82u8, + 69u8, 83u8, 83u8, 32u8, 79u8, 82u8, 32u8, 73u8, 77u8, 80u8, 76u8, 73u8, 69u8, + 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, 73u8, 69u8, 83u8, 44u8, + 32u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, 44u8, 32u8, 66u8, + 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, 76u8, 73u8, 77u8, 73u8, 84u8, + 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 84u8, 72u8, 69u8, 32u8, 73u8, 77u8, + 80u8, 76u8, 73u8, 69u8, 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, + 73u8, 69u8, 83u8, 32u8, 79u8, 70u8, 32u8, 77u8, 69u8, 82u8, 67u8, 72u8, 65u8, + 78u8, 84u8, 65u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 65u8, 78u8, 68u8, + 32u8, 70u8, 73u8, 84u8, 78u8, 69u8, 83u8, 83u8, 32u8, 70u8, 79u8, 82u8, 10u8, + 32u8, 65u8, 32u8, 80u8, 65u8, 82u8, 84u8, 73u8, 67u8, 85u8, 76u8, 65u8, 82u8, + 32u8, 80u8, 85u8, 82u8, 80u8, 79u8, 83u8, 69u8, 32u8, 65u8, 82u8, 69u8, 32u8, + 68u8, 73u8, 83u8, 67u8, 76u8, 65u8, 73u8, 77u8, 69u8, 68u8, 46u8, 32u8, 73u8, + 78u8, 32u8, 78u8, 79u8, 32u8, 69u8, 86u8, 69u8, 78u8, 84u8, 32u8, 83u8, 72u8, + 65u8, 76u8, 76u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, 82u8, + 73u8, 71u8, 72u8, 84u8, 10u8, 32u8, 79u8, 87u8, 78u8, 69u8, 82u8, 32u8, 79u8, + 82u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, 84u8, 79u8, 82u8, + 83u8, 32u8, 66u8, 69u8, 32u8, 76u8, 73u8, 65u8, 66u8, 76u8, 69u8, 32u8, 70u8, + 79u8, 82u8, 32u8, 65u8, 78u8, 89u8, 32u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, + 44u8, 32u8, 73u8, 78u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, 44u8, 32u8, 73u8, + 78u8, 67u8, 73u8, 68u8, 69u8, 78u8, 84u8, 65u8, 76u8, 44u8, 10u8, 32u8, 83u8, + 80u8, 69u8, 67u8, 73u8, 65u8, 76u8, 44u8, 32u8, 69u8, 88u8, 69u8, 77u8, 80u8, + 76u8, 65u8, 82u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 67u8, 79u8, 78u8, 83u8, + 69u8, 81u8, 85u8, 69u8, 78u8, 84u8, 73u8, 65u8, 76u8, 32u8, 68u8, 65u8, 77u8, + 65u8, 71u8, 69u8, 83u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, + 78u8, 71u8, 44u8, 32u8, 66u8, 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, + 76u8, 73u8, 77u8, 73u8, 84u8, 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 80u8, + 82u8, 79u8, 67u8, 85u8, 82u8, 69u8, 77u8, 69u8, 78u8, 84u8, 32u8, 79u8, 70u8, + 32u8, 83u8, 85u8, 66u8, 83u8, 84u8, 73u8, 84u8, 85u8, 84u8, 69u8, 32u8, 71u8, + 79u8, 79u8, 68u8, 83u8, 32u8, 79u8, 82u8, 32u8, 83u8, 69u8, 82u8, 86u8, 73u8, + 67u8, 69u8, 83u8, 59u8, 32u8, 76u8, 79u8, 83u8, 83u8, 32u8, 79u8, 70u8, 32u8, + 85u8, 83u8, 69u8, 44u8, 10u8, 32u8, 68u8, 65u8, 84u8, 65u8, 44u8, 32u8, 79u8, + 82u8, 32u8, 80u8, 82u8, 79u8, 70u8, 73u8, 84u8, 83u8, 59u8, 32u8, 79u8, 82u8, + 32u8, 66u8, 85u8, 83u8, 73u8, 78u8, 69u8, 83u8, 83u8, 32u8, 73u8, 78u8, 84u8, + 69u8, 82u8, 82u8, 85u8, 80u8, 84u8, 73u8, 79u8, 78u8, 41u8, 32u8, 72u8, 79u8, + 87u8, 69u8, 86u8, 69u8, 82u8, 32u8, 67u8, 65u8, 85u8, 83u8, 69u8, 68u8, 32u8, + 65u8, 78u8, 68u8, 32u8, 79u8, 78u8, 32u8, 65u8, 78u8, 89u8, 10u8, 32u8, 84u8, + 72u8, 69u8, 79u8, 82u8, 89u8, 32u8, 79u8, 70u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 87u8, 72u8, 69u8, 84u8, 72u8, 69u8, + 82u8, 32u8, 73u8, 78u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 65u8, 67u8, 84u8, + 44u8, 32u8, 83u8, 84u8, 82u8, 73u8, 67u8, 84u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 84u8, 79u8, 82u8, + 84u8, 10u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, + 32u8, 78u8, 69u8, 71u8, 76u8, 73u8, 71u8, 69u8, 78u8, 67u8, 69u8, 32u8, 79u8, + 82u8, 32u8, 79u8, 84u8, 72u8, 69u8, 82u8, 87u8, 73u8, 83u8, 69u8, 41u8, 32u8, + 65u8, 82u8, 73u8, 83u8, 73u8, 78u8, 71u8, 32u8, 73u8, 78u8, 32u8, 65u8, 78u8, + 89u8, 32u8, 87u8, 65u8, 89u8, 32u8, 79u8, 85u8, 84u8, 32u8, 79u8, 70u8, 32u8, + 84u8, 72u8, 69u8, 32u8, 85u8, 83u8, 69u8, 10u8, 32u8, 79u8, 70u8, 32u8, 84u8, + 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, 82u8, 69u8, 44u8, + 32u8, 69u8, 86u8, 69u8, 78u8, 32u8, 73u8, 70u8, 32u8, 65u8, 68u8, 86u8, 73u8, + 83u8, 69u8, 68u8, 32u8, 79u8, 70u8, 32u8, 84u8, 72u8, 69u8, 32u8, 80u8, 79u8, + 83u8, 83u8, 73u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 79u8, 70u8, 32u8, + 83u8, 85u8, 67u8, 72u8, 32u8, 68u8, 65u8, 77u8, 65u8, 71u8, 69u8, 46u8, 10u8, + 10u8, 8u8, 10u8, 1u8, 2u8, 18u8, 3u8, 32u8, 0u8, 24u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 34u8, 0u8, 31u8, 10u8, 9u8, 10u8, 2u8, 8u8, 31u8, 18u8, 3u8, + 34u8, 0u8, 31u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 35u8, 0u8, 72u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 11u8, 18u8, 3u8, 35u8, 0u8, 72u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 36u8, 0u8, 44u8, 10u8, 9u8, 10u8, 2u8, 8u8, 1u8, 18u8, 3u8, + 36u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 37u8, 0u8, 46u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 8u8, 18u8, 3u8, 37u8, 0u8, 46u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 38u8, 0u8, 34u8, 10u8, 9u8, 10u8, 2u8, 8u8, 10u8, 18u8, 3u8, + 38u8, 0u8, 34u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 39u8, 0u8, 33u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 36u8, 18u8, 3u8, 39u8, 0u8, 33u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 40u8, 0u8, 59u8, 10u8, 9u8, 10u8, 2u8, 8u8, 37u8, 18u8, 3u8, + 40u8, 0u8, 59u8, 10u8, 157u8, 16u8, 10u8, 2u8, 4u8, 0u8, 18u8, 4u8, 101u8, + 0u8, 114u8, 1u8, 26u8, 144u8, 16u8, 32u8, 65u8, 32u8, 68u8, 117u8, 114u8, + 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, + 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, 32u8, 115u8, 105u8, 103u8, + 110u8, 101u8, 100u8, 44u8, 32u8, 102u8, 105u8, 120u8, 101u8, 100u8, 45u8, + 108u8, 101u8, 110u8, 103u8, 116u8, 104u8, 32u8, 115u8, 112u8, 97u8, 110u8, + 32u8, 111u8, 102u8, 32u8, 116u8, 105u8, 109u8, 101u8, 32u8, 114u8, 101u8, + 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 101u8, 100u8, 10u8, 32u8, + 97u8, 115u8, 32u8, 97u8, 32u8, 99u8, 111u8, 117u8, 110u8, 116u8, 32u8, 111u8, + 102u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 97u8, + 110u8, 100u8, 32u8, 102u8, 114u8, 97u8, 99u8, 116u8, 105u8, 111u8, 110u8, + 115u8, 32u8, 111u8, 102u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, + 115u8, 32u8, 97u8, 116u8, 32u8, 110u8, 97u8, 110u8, 111u8, 115u8, 101u8, + 99u8, 111u8, 110u8, 100u8, 10u8, 32u8, 114u8, 101u8, 115u8, 111u8, 108u8, + 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, 32u8, 73u8, 116u8, 32u8, 105u8, + 115u8, 32u8, 105u8, 110u8, 100u8, 101u8, 112u8, 101u8, 110u8, 100u8, 101u8, + 110u8, 116u8, 32u8, 111u8, 102u8, 32u8, 97u8, 110u8, 121u8, 32u8, 99u8, 97u8, + 108u8, 101u8, 110u8, 100u8, 97u8, 114u8, 32u8, 97u8, 110u8, 100u8, 32u8, + 99u8, 111u8, 110u8, 99u8, 101u8, 112u8, 116u8, 115u8, 32u8, 108u8, 105u8, + 107u8, 101u8, 32u8, 34u8, 100u8, 97u8, 121u8, 34u8, 10u8, 32u8, 111u8, 114u8, + 32u8, 34u8, 109u8, 111u8, 110u8, 116u8, 104u8, 34u8, 46u8, 32u8, 73u8, 116u8, + 32u8, 105u8, 115u8, 32u8, 114u8, 101u8, 108u8, 97u8, 116u8, 101u8, 100u8, + 32u8, 116u8, 111u8, 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, + 109u8, 112u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 100u8, 105u8, 102u8, 102u8, 101u8, 114u8, 101u8, + 110u8, 99u8, 101u8, 32u8, 98u8, 101u8, 116u8, 119u8, 101u8, 101u8, 110u8, + 10u8, 32u8, 116u8, 119u8, 111u8, 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, + 116u8, 97u8, 109u8, 112u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, + 32u8, 105u8, 115u8, 32u8, 97u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 32u8, 97u8, 110u8, 100u8, 32u8, 105u8, 116u8, 32u8, 99u8, 97u8, + 110u8, 32u8, 98u8, 101u8, 32u8, 97u8, 100u8, 100u8, 101u8, 100u8, 32u8, + 111u8, 114u8, 32u8, 115u8, 117u8, 98u8, 116u8, 114u8, 97u8, 99u8, 116u8, + 101u8, 100u8, 10u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, 97u8, 32u8, 84u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 46u8, 32u8, 82u8, + 97u8, 110u8, 103u8, 101u8, 32u8, 105u8, 115u8, 32u8, 97u8, 112u8, 112u8, + 114u8, 111u8, 120u8, 105u8, 109u8, 97u8, 116u8, 101u8, 108u8, 121u8, 32u8, + 43u8, 45u8, 49u8, 48u8, 44u8, 48u8, 48u8, 48u8, 32u8, 121u8, 101u8, 97u8, + 114u8, 115u8, 46u8, 10u8, 10u8, 32u8, 35u8, 32u8, 69u8, 120u8, 97u8, 109u8, + 112u8, 108u8, 101u8, 115u8, 10u8, 10u8, 32u8, 69u8, 120u8, 97u8, 109u8, + 112u8, 108u8, 101u8, 32u8, 49u8, 58u8, 32u8, 67u8, 111u8, 109u8, 112u8, + 117u8, 116u8, 101u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, + 110u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, 116u8, 119u8, 111u8, 32u8, + 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 115u8, 32u8, + 105u8, 110u8, 32u8, 112u8, 115u8, 101u8, 117u8, 100u8, 111u8, 32u8, 99u8, + 111u8, 100u8, 101u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 84u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 115u8, 116u8, + 97u8, 114u8, 116u8, 32u8, 61u8, 32u8, 46u8, 46u8, 46u8, 59u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, + 112u8, 32u8, 101u8, 110u8, 100u8, 32u8, 61u8, 32u8, 46u8, 46u8, 46u8, 59u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 32u8, 61u8, 32u8, 46u8, 46u8, 46u8, 59u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 61u8, 32u8, 101u8, 110u8, + 100u8, 46u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 45u8, + 32u8, 115u8, 116u8, 97u8, 114u8, 116u8, 46u8, 115u8, 101u8, 99u8, 111u8, + 110u8, 100u8, 115u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 100u8, 117u8, + 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, 110u8, 97u8, 110u8, 111u8, + 115u8, 32u8, 61u8, 32u8, 101u8, 110u8, 100u8, 46u8, 110u8, 97u8, 110u8, + 111u8, 115u8, 32u8, 45u8, 32u8, 115u8, 116u8, 97u8, 114u8, 116u8, 46u8, + 110u8, 97u8, 110u8, 111u8, 115u8, 59u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 105u8, 102u8, 32u8, 40u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 46u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, + 60u8, 32u8, 48u8, 32u8, 38u8, 38u8, 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, 32u8, 62u8, + 32u8, 48u8, 41u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 43u8, 61u8, 32u8, 49u8, 59u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 100u8, 117u8, 114u8, 97u8, + 116u8, 105u8, 111u8, 110u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, 32u8, + 45u8, 61u8, 32u8, 49u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, + 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 32u8, 101u8, 108u8, 115u8, + 101u8, 32u8, 105u8, 102u8, 32u8, 40u8, 100u8, 117u8, 114u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 46u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, + 32u8, 62u8, 32u8, 48u8, 32u8, 38u8, 38u8, 32u8, 100u8, 117u8, 114u8, 97u8, + 116u8, 105u8, 111u8, 110u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, 32u8, + 60u8, 32u8, 48u8, 41u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, + 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 45u8, 61u8, 32u8, 49u8, + 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 100u8, 117u8, 114u8, + 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, + 32u8, 43u8, 61u8, 32u8, 49u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, + 48u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, + 69u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 50u8, 58u8, 32u8, 67u8, + 111u8, 109u8, 112u8, 117u8, 116u8, 101u8, 32u8, 84u8, 105u8, 109u8, 101u8, + 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, + 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 43u8, + 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 105u8, + 110u8, 32u8, 112u8, 115u8, 101u8, 117u8, 100u8, 111u8, 32u8, 99u8, 111u8, + 100u8, 101u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 84u8, 105u8, + 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 115u8, 116u8, 97u8, + 114u8, 116u8, 32u8, 61u8, 32u8, 46u8, 46u8, 46u8, 59u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 61u8, 32u8, + 46u8, 46u8, 46u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 84u8, 105u8, + 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 101u8, 110u8, 100u8, + 32u8, 61u8, 32u8, 46u8, 46u8, 46u8, 59u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 101u8, 110u8, 100u8, 46u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, + 115u8, 32u8, 61u8, 32u8, 115u8, 116u8, 97u8, 114u8, 116u8, 46u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 43u8, 32u8, 100u8, 117u8, + 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, 115u8, 101u8, 99u8, 111u8, + 110u8, 100u8, 115u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 101u8, 110u8, + 100u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, 32u8, 61u8, 32u8, 115u8, + 116u8, 97u8, 114u8, 116u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, 32u8, + 43u8, 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, + 110u8, 97u8, 110u8, 111u8, 115u8, 59u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 105u8, 102u8, 32u8, 40u8, 101u8, 110u8, 100u8, 46u8, 110u8, 97u8, + 110u8, 111u8, 115u8, 32u8, 60u8, 32u8, 48u8, 41u8, 32u8, 123u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 101u8, 110u8, 100u8, 46u8, 115u8, 101u8, + 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 45u8, 61u8, 32u8, 49u8, 59u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 101u8, 110u8, 100u8, 46u8, 110u8, + 97u8, 110u8, 111u8, 115u8, 32u8, 43u8, 61u8, 32u8, 49u8, 48u8, 48u8, 48u8, + 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 125u8, 32u8, 101u8, 108u8, 115u8, 101u8, 32u8, 105u8, 102u8, 32u8, 40u8, + 101u8, 110u8, 100u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, 32u8, 62u8, + 61u8, 32u8, 49u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 41u8, + 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 101u8, 110u8, + 100u8, 46u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 43u8, + 61u8, 32u8, 49u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 101u8, 110u8, 100u8, 46u8, 110u8, 97u8, 110u8, 111u8, 115u8, 32u8, 45u8, + 61u8, 32u8, 49u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 59u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 69u8, 120u8, + 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 51u8, 58u8, 32u8, 67u8, 111u8, 109u8, + 112u8, 117u8, 116u8, 101u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, 100u8, 97u8, 116u8, + 101u8, 116u8, 105u8, 109u8, 101u8, 46u8, 116u8, 105u8, 109u8, 101u8, 100u8, + 101u8, 108u8, 116u8, 97u8, 32u8, 105u8, 110u8, 32u8, 80u8, 121u8, 116u8, + 104u8, 111u8, 110u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 116u8, + 100u8, 32u8, 61u8, 32u8, 100u8, 97u8, 116u8, 101u8, 116u8, 105u8, 109u8, + 101u8, 46u8, 116u8, 105u8, 109u8, 101u8, 100u8, 101u8, 108u8, 116u8, 97u8, + 40u8, 100u8, 97u8, 121u8, 115u8, 61u8, 51u8, 44u8, 32u8, 109u8, 105u8, 110u8, + 117u8, 116u8, 101u8, 115u8, 61u8, 49u8, 48u8, 41u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 61u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 40u8, 41u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 46u8, 70u8, 114u8, 111u8, 109u8, 84u8, 105u8, 109u8, 101u8, + 100u8, 101u8, 108u8, 116u8, 97u8, 40u8, 116u8, 100u8, 41u8, 10u8, 10u8, 32u8, + 35u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 77u8, 97u8, 112u8, 112u8, 105u8, + 110u8, 103u8, 10u8, 10u8, 32u8, 73u8, 110u8, 32u8, 74u8, 83u8, 79u8, 78u8, + 32u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 44u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 116u8, 121u8, 112u8, 101u8, 32u8, 105u8, 115u8, 32u8, 101u8, 110u8, 99u8, + 111u8, 100u8, 101u8, 100u8, 32u8, 97u8, 115u8, 32u8, 97u8, 32u8, 115u8, + 116u8, 114u8, 105u8, 110u8, 103u8, 32u8, 114u8, 97u8, 116u8, 104u8, 101u8, + 114u8, 32u8, 116u8, 104u8, 97u8, 110u8, 32u8, 97u8, 110u8, 10u8, 32u8, 111u8, + 98u8, 106u8, 101u8, 99u8, 116u8, 44u8, 32u8, 119u8, 104u8, 101u8, 114u8, + 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, + 103u8, 32u8, 101u8, 110u8, 100u8, 115u8, 32u8, 105u8, 110u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 115u8, 117u8, 102u8, 102u8, 105u8, 120u8, 32u8, 34u8, + 115u8, 34u8, 32u8, 40u8, 105u8, 110u8, 100u8, 105u8, 99u8, 97u8, 116u8, + 105u8, 110u8, 103u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, + 41u8, 32u8, 97u8, 110u8, 100u8, 10u8, 32u8, 105u8, 115u8, 32u8, 112u8, 114u8, + 101u8, 99u8, 101u8, 100u8, 101u8, 100u8, 32u8, 98u8, 121u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 110u8, 117u8, 109u8, 98u8, 101u8, 114u8, 32u8, 111u8, + 102u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 44u8, 32u8, + 119u8, 105u8, 116u8, 104u8, 32u8, 110u8, 97u8, 110u8, 111u8, 115u8, 101u8, + 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 101u8, 120u8, 112u8, 114u8, 101u8, + 115u8, 115u8, 101u8, 100u8, 32u8, 97u8, 115u8, 10u8, 32u8, 102u8, 114u8, + 97u8, 99u8, 116u8, 105u8, 111u8, 110u8, 97u8, 108u8, 32u8, 115u8, 101u8, + 99u8, 111u8, 110u8, 100u8, 115u8, 46u8, 32u8, 70u8, 111u8, 114u8, 32u8, + 101u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 44u8, 32u8, 51u8, 32u8, + 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 119u8, 105u8, 116u8, + 104u8, 32u8, 48u8, 32u8, 110u8, 97u8, 110u8, 111u8, 115u8, 101u8, 99u8, + 111u8, 110u8, 100u8, 115u8, 32u8, 115u8, 104u8, 111u8, 117u8, 108u8, 100u8, + 32u8, 98u8, 101u8, 10u8, 32u8, 101u8, 110u8, 99u8, 111u8, 100u8, 101u8, + 100u8, 32u8, 105u8, 110u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 102u8, 111u8, + 114u8, 109u8, 97u8, 116u8, 32u8, 97u8, 115u8, 32u8, 34u8, 51u8, 115u8, 34u8, + 44u8, 32u8, 119u8, 104u8, 105u8, 108u8, 101u8, 32u8, 51u8, 32u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, + 49u8, 32u8, 110u8, 97u8, 110u8, 111u8, 115u8, 101u8, 99u8, 111u8, 110u8, + 100u8, 32u8, 115u8, 104u8, 111u8, 117u8, 108u8, 100u8, 10u8, 32u8, 98u8, + 101u8, 32u8, 101u8, 120u8, 112u8, 114u8, 101u8, 115u8, 115u8, 101u8, 100u8, + 32u8, 105u8, 110u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 97u8, 116u8, 32u8, 97u8, 115u8, 32u8, 34u8, 51u8, 46u8, 48u8, 48u8, + 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 49u8, 115u8, 34u8, 44u8, 32u8, 97u8, + 110u8, 100u8, 32u8, 51u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, + 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 49u8, 10u8, 32u8, 109u8, 105u8, 99u8, + 114u8, 111u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 32u8, 115u8, 104u8, + 111u8, 117u8, 108u8, 100u8, 32u8, 98u8, 101u8, 32u8, 101u8, 120u8, 112u8, + 114u8, 101u8, 115u8, 115u8, 101u8, 100u8, 32u8, 105u8, 110u8, 32u8, 74u8, + 83u8, 79u8, 78u8, 32u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 32u8, 97u8, + 115u8, 32u8, 34u8, 51u8, 46u8, 48u8, 48u8, 48u8, 48u8, 48u8, 49u8, 115u8, + 34u8, 46u8, 10u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 0u8, 1u8, 18u8, 3u8, + 101u8, 8u8, 16u8, 10u8, 220u8, 1u8, 10u8, 4u8, 4u8, 0u8, 2u8, 0u8, 18u8, 3u8, + 105u8, 2u8, 20u8, 26u8, 206u8, 1u8, 32u8, 83u8, 105u8, 103u8, 110u8, 101u8, + 100u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 111u8, + 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 115u8, 112u8, 97u8, 110u8, 32u8, + 111u8, 102u8, 32u8, 116u8, 105u8, 109u8, 101u8, 46u8, 32u8, 77u8, 117u8, + 115u8, 116u8, 32u8, 98u8, 101u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, + 45u8, 51u8, 49u8, 53u8, 44u8, 53u8, 55u8, 54u8, 44u8, 48u8, 48u8, 48u8, 44u8, + 48u8, 48u8, 48u8, 10u8, 32u8, 116u8, 111u8, 32u8, 43u8, 51u8, 49u8, 53u8, + 44u8, 53u8, 55u8, 54u8, 44u8, 48u8, 48u8, 48u8, 44u8, 48u8, 48u8, 48u8, 32u8, + 105u8, 110u8, 99u8, 108u8, 117u8, 115u8, 105u8, 118u8, 101u8, 46u8, 32u8, + 78u8, 111u8, 116u8, 101u8, 58u8, 32u8, 116u8, 104u8, 101u8, 115u8, 101u8, + 32u8, 98u8, 111u8, 117u8, 110u8, 100u8, 115u8, 32u8, 97u8, 114u8, 101u8, + 32u8, 99u8, 111u8, 109u8, 112u8, 117u8, 116u8, 101u8, 100u8, 32u8, 102u8, + 114u8, 111u8, 109u8, 58u8, 10u8, 32u8, 54u8, 48u8, 32u8, 115u8, 101u8, 99u8, + 47u8, 109u8, 105u8, 110u8, 32u8, 42u8, 32u8, 54u8, 48u8, 32u8, 109u8, 105u8, + 110u8, 47u8, 104u8, 114u8, 32u8, 42u8, 32u8, 50u8, 52u8, 32u8, 104u8, 114u8, + 47u8, 100u8, 97u8, 121u8, 32u8, 42u8, 32u8, 51u8, 54u8, 53u8, 46u8, 50u8, + 53u8, 32u8, 100u8, 97u8, 121u8, 115u8, 47u8, 121u8, 101u8, 97u8, 114u8, 32u8, + 42u8, 32u8, 49u8, 48u8, 48u8, 48u8, 48u8, 32u8, 121u8, 101u8, 97u8, 114u8, + 115u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 5u8, 18u8, 3u8, + 105u8, 2u8, 7u8, 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 1u8, 18u8, 3u8, + 105u8, 8u8, 15u8, 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 3u8, 18u8, 3u8, + 105u8, 18u8, 19u8, 10u8, 131u8, 3u8, 10u8, 4u8, 4u8, 0u8, 2u8, 1u8, 18u8, + 3u8, 113u8, 2u8, 18u8, 26u8, 245u8, 2u8, 32u8, 83u8, 105u8, 103u8, 110u8, + 101u8, 100u8, 32u8, 102u8, 114u8, 97u8, 99u8, 116u8, 105u8, 111u8, 110u8, + 115u8, 32u8, 111u8, 102u8, 32u8, 97u8, 32u8, 115u8, 101u8, 99u8, 111u8, + 110u8, 100u8, 32u8, 97u8, 116u8, 32u8, 110u8, 97u8, 110u8, 111u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 32u8, 114u8, 101u8, 115u8, 111u8, 108u8, + 117u8, 116u8, 105u8, 111u8, 110u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 115u8, 112u8, 97u8, 110u8, 10u8, 32u8, 111u8, 102u8, 32u8, + 116u8, 105u8, 109u8, 101u8, 46u8, 32u8, 68u8, 117u8, 114u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 115u8, 32u8, 108u8, 101u8, 115u8, 115u8, 32u8, 116u8, + 104u8, 97u8, 110u8, 32u8, 111u8, 110u8, 101u8, 32u8, 115u8, 101u8, 99u8, + 111u8, 110u8, 100u8, 32u8, 97u8, 114u8, 101u8, 32u8, 114u8, 101u8, 112u8, + 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 101u8, 100u8, 32u8, 119u8, 105u8, + 116u8, 104u8, 32u8, 97u8, 32u8, 48u8, 10u8, 32u8, 96u8, 115u8, 101u8, 99u8, + 111u8, 110u8, 100u8, 115u8, 96u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 97u8, 32u8, 112u8, 111u8, 115u8, 105u8, + 116u8, 105u8, 118u8, 101u8, 32u8, 111u8, 114u8, 32u8, 110u8, 101u8, 103u8, + 97u8, 116u8, 105u8, 118u8, 101u8, 32u8, 96u8, 110u8, 97u8, 110u8, 111u8, + 115u8, 96u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 46u8, 32u8, 70u8, + 111u8, 114u8, 32u8, 100u8, 117u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 115u8, 10u8, 32u8, 111u8, 102u8, 32u8, 111u8, 110u8, 101u8, 32u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 32u8, 111u8, 114u8, 32u8, 109u8, 111u8, + 114u8, 101u8, 44u8, 32u8, 97u8, 32u8, 110u8, 111u8, 110u8, 45u8, 122u8, + 101u8, 114u8, 111u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 32u8, 102u8, + 111u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 96u8, 110u8, 97u8, 110u8, + 111u8, 115u8, 96u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, + 117u8, 115u8, 116u8, 32u8, 98u8, 101u8, 10u8, 32u8, 111u8, 102u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 115u8, 97u8, 109u8, 101u8, 32u8, 115u8, 105u8, + 103u8, 110u8, 32u8, 97u8, 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, 96u8, + 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 96u8, 32u8, 102u8, 105u8, + 101u8, 108u8, 100u8, 46u8, 32u8, 77u8, 117u8, 115u8, 116u8, 32u8, 98u8, + 101u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, 45u8, 57u8, 57u8, 57u8, 44u8, + 57u8, 57u8, 57u8, 44u8, 57u8, 57u8, 57u8, 10u8, 32u8, 116u8, 111u8, 32u8, + 43u8, 57u8, 57u8, 57u8, 44u8, 57u8, 57u8, 57u8, 44u8, 57u8, 57u8, 57u8, 32u8, + 105u8, 110u8, 99u8, 108u8, 117u8, 115u8, 105u8, 118u8, 101u8, 46u8, 10u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 1u8, 5u8, 18u8, 3u8, 113u8, 2u8, 7u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 1u8, 1u8, 18u8, 3u8, 113u8, 8u8, 13u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 1u8, 3u8, 18u8, 3u8, 113u8, 16u8, 17u8, + 98u8, 6u8, 112u8, 114u8, 111u8, 116u8, 111u8, 51u8, 10u8, 179u8, 7u8, 10u8, + 27u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 47u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 98u8, 117u8, 102u8, 47u8, 101u8, 109u8, 112u8, 116u8, 121u8, + 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 18u8, 15u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 34u8, 7u8, 10u8, 5u8, 69u8, 109u8, 112u8, 116u8, 121u8, 66u8, 122u8, + 10u8, 19u8, 99u8, 111u8, 109u8, 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, + 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 66u8, + 10u8, 69u8, 109u8, 112u8, 116u8, 121u8, 80u8, 114u8, 111u8, 116u8, 111u8, + 80u8, 1u8, 90u8, 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 103u8, + 111u8, 108u8, 97u8, 110u8, 103u8, 46u8, 111u8, 114u8, 103u8, 47u8, 112u8, + 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 47u8, 116u8, 121u8, 112u8, + 101u8, 115u8, 47u8, 107u8, 110u8, 111u8, 119u8, 110u8, 47u8, 101u8, 109u8, + 112u8, 116u8, 121u8, 112u8, 98u8, 162u8, 2u8, 3u8, 71u8, 80u8, 66u8, 170u8, + 2u8, 30u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 80u8, 114u8, 111u8, + 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 87u8, 101u8, 108u8, 108u8, 75u8, + 110u8, 111u8, 119u8, 110u8, 84u8, 121u8, 112u8, 101u8, 115u8, 74u8, 245u8, + 5u8, 10u8, 6u8, 18u8, 4u8, 7u8, 0u8, 25u8, 16u8, 10u8, 148u8, 2u8, 10u8, 1u8, + 12u8, 18u8, 3u8, 7u8, 0u8, 18u8, 50u8, 137u8, 2u8, 32u8, 80u8, 114u8, 111u8, + 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, 66u8, 117u8, 102u8, 102u8, 101u8, + 114u8, 115u8, 32u8, 45u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 39u8, 115u8, 32u8, 100u8, 97u8, 116u8, 97u8, 32u8, 105u8, 110u8, 116u8, + 101u8, 114u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, 32u8, 102u8, 111u8, + 114u8, 109u8, 97u8, 116u8, 10u8, 32u8, 67u8, 111u8, 112u8, 121u8, 114u8, + 105u8, 103u8, 104u8, 116u8, 32u8, 50u8, 48u8, 48u8, 56u8, 32u8, 71u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 32u8, 65u8, + 108u8, 108u8, 32u8, 114u8, 105u8, 103u8, 104u8, 116u8, 115u8, 32u8, 114u8, + 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, 46u8, 10u8, 10u8, 32u8, + 85u8, 115u8, 101u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 105u8, 115u8, + 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 99u8, 111u8, 100u8, + 101u8, 32u8, 105u8, 115u8, 32u8, 103u8, 111u8, 118u8, 101u8, 114u8, 110u8, + 101u8, 100u8, 32u8, 98u8, 121u8, 32u8, 97u8, 32u8, 66u8, 83u8, 68u8, 45u8, + 115u8, 116u8, 121u8, 108u8, 101u8, 10u8, 32u8, 108u8, 105u8, 99u8, 101u8, + 110u8, 115u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 99u8, 97u8, + 110u8, 32u8, 98u8, 101u8, 32u8, 102u8, 111u8, 117u8, 110u8, 100u8, 32u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 76u8, 73u8, 67u8, 69u8, 78u8, + 83u8, 69u8, 32u8, 102u8, 105u8, 108u8, 101u8, 32u8, 111u8, 114u8, 32u8, 97u8, + 116u8, 10u8, 32u8, 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, + 100u8, 101u8, 118u8, 101u8, 108u8, 111u8, 112u8, 101u8, 114u8, 115u8, 46u8, + 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 99u8, 111u8, 109u8, 47u8, + 111u8, 112u8, 101u8, 110u8, 45u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, + 47u8, 108u8, 105u8, 99u8, 101u8, 110u8, 115u8, 101u8, 115u8, 47u8, 98u8, + 115u8, 100u8, 10u8, 10u8, 8u8, 10u8, 1u8, 2u8, 18u8, 3u8, 9u8, 0u8, 24u8, + 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 11u8, 0u8, 44u8, 10u8, 9u8, 10u8, 2u8, + 8u8, 1u8, 18u8, 3u8, 11u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, + 12u8, 0u8, 43u8, 10u8, 9u8, 10u8, 2u8, 8u8, 8u8, 18u8, 3u8, 12u8, 0u8, 43u8, + 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 13u8, 0u8, 34u8, 10u8, 9u8, 10u8, 2u8, + 8u8, 10u8, 18u8, 3u8, 13u8, 0u8, 34u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, + 14u8, 0u8, 69u8, 10u8, 9u8, 10u8, 2u8, 8u8, 11u8, 18u8, 3u8, 14u8, 0u8, 69u8, + 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 15u8, 0u8, 33u8, 10u8, 9u8, 10u8, 2u8, + 8u8, 36u8, 18u8, 3u8, 15u8, 0u8, 33u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, + 16u8, 0u8, 59u8, 10u8, 9u8, 10u8, 2u8, 8u8, 37u8, 18u8, 3u8, 16u8, 0u8, 59u8, + 10u8, 191u8, 2u8, 10u8, 2u8, 4u8, 0u8, 18u8, 3u8, 25u8, 0u8, 16u8, 26u8, + 179u8, 2u8, 32u8, 65u8, 32u8, 103u8, 101u8, 110u8, 101u8, 114u8, 105u8, 99u8, + 32u8, 101u8, 109u8, 112u8, 116u8, 121u8, 32u8, 109u8, 101u8, 115u8, 115u8, + 97u8, 103u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 121u8, 111u8, + 117u8, 32u8, 99u8, 97u8, 110u8, 32u8, 114u8, 101u8, 45u8, 117u8, 115u8, + 101u8, 32u8, 116u8, 111u8, 32u8, 97u8, 118u8, 111u8, 105u8, 100u8, 32u8, + 100u8, 101u8, 102u8, 105u8, 110u8, 105u8, 110u8, 103u8, 32u8, 100u8, 117u8, + 112u8, 108u8, 105u8, 99u8, 97u8, 116u8, 101u8, 100u8, 10u8, 32u8, 101u8, + 109u8, 112u8, 116u8, 121u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, + 101u8, 115u8, 32u8, 105u8, 110u8, 32u8, 121u8, 111u8, 117u8, 114u8, 32u8, + 65u8, 80u8, 73u8, 115u8, 46u8, 10u8, 10u8, 32u8, 69u8, 120u8, 97u8, 109u8, + 112u8, 108u8, 101u8, 32u8, 117u8, 115u8, 97u8, 103u8, 101u8, 58u8, 32u8, + 103u8, 82u8, 80u8, 67u8, 32u8, 117u8, 115u8, 101u8, 115u8, 32u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 98u8, 117u8, 102u8, 46u8, 69u8, 109u8, 112u8, 116u8, 121u8, 32u8, 97u8, + 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, 105u8, 110u8, 112u8, 117u8, 116u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 111u8, 117u8, 116u8, 112u8, 117u8, 116u8, + 10u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 102u8, 111u8, 114u8, 32u8, + 82u8, 80u8, 67u8, 115u8, 32u8, 100u8, 101u8, 102u8, 105u8, 110u8, 101u8, + 100u8, 32u8, 97u8, 115u8, 32u8, 114u8, 101u8, 116u8, 117u8, 114u8, 110u8, + 105u8, 110u8, 103u8, 32u8, 111u8, 114u8, 32u8, 97u8, 99u8, 99u8, 101u8, + 112u8, 116u8, 105u8, 110u8, 103u8, 32u8, 34u8, 110u8, 111u8, 116u8, 104u8, + 105u8, 110u8, 103u8, 34u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 114u8, 112u8, 99u8, 32u8, 66u8, 97u8, 114u8, 40u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 46u8, 69u8, 109u8, 112u8, 116u8, 121u8, 41u8, 32u8, 114u8, 101u8, + 116u8, 117u8, 114u8, 110u8, 115u8, 32u8, 40u8, 103u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, + 46u8, 69u8, 109u8, 112u8, 116u8, 121u8, 41u8, 59u8, 10u8, 10u8, 10u8, 10u8, + 3u8, 4u8, 0u8, 1u8, 18u8, 3u8, 25u8, 8u8, 13u8, 98u8, 6u8, 112u8, 114u8, + 111u8, 116u8, 111u8, 51u8, 10u8, 138u8, 61u8, 10u8, 32u8, 103u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, + 117u8, 102u8, 47u8, 102u8, 105u8, 101u8, 108u8, 100u8, 95u8, 109u8, 97u8, + 115u8, 107u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 18u8, 15u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 98u8, 117u8, 102u8, 34u8, 33u8, 10u8, 9u8, 70u8, 105u8, 101u8, 108u8, 100u8, + 77u8, 97u8, 115u8, 107u8, 18u8, 20u8, 10u8, 5u8, 112u8, 97u8, 116u8, 104u8, + 115u8, 24u8, 1u8, 32u8, 3u8, 40u8, 9u8, 82u8, 5u8, 112u8, 97u8, 116u8, 104u8, + 115u8, 66u8, 133u8, 1u8, 10u8, 19u8, 99u8, 111u8, 109u8, 46u8, 103u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, + 117u8, 102u8, 66u8, 14u8, 70u8, 105u8, 101u8, 108u8, 100u8, 77u8, 97u8, + 115u8, 107u8, 80u8, 114u8, 111u8, 116u8, 111u8, 80u8, 1u8, 90u8, 50u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 103u8, 111u8, 108u8, 97u8, 110u8, + 103u8, 46u8, 111u8, 114u8, 103u8, 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 98u8, 117u8, 102u8, 47u8, 116u8, 121u8, 112u8, 101u8, 115u8, 47u8, 107u8, + 110u8, 111u8, 119u8, 110u8, 47u8, 102u8, 105u8, 101u8, 108u8, 100u8, 109u8, + 97u8, 115u8, 107u8, 112u8, 98u8, 248u8, 1u8, 1u8, 162u8, 2u8, 3u8, 71u8, + 80u8, 66u8, 170u8, 2u8, 30u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, + 80u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 87u8, 101u8, + 108u8, 108u8, 75u8, 110u8, 111u8, 119u8, 110u8, 84u8, 121u8, 112u8, 101u8, + 115u8, 74u8, 161u8, 59u8, 10u8, 7u8, 18u8, 5u8, 30u8, 0u8, 244u8, 1u8, 1u8, + 10u8, 204u8, 12u8, 10u8, 1u8, 12u8, 18u8, 3u8, 30u8, 0u8, 18u8, 50u8, 193u8, + 12u8, 32u8, 80u8, 114u8, 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, 66u8, + 117u8, 102u8, 102u8, 101u8, 114u8, 115u8, 32u8, 45u8, 32u8, 71u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 39u8, 115u8, 32u8, 100u8, 97u8, 116u8, 97u8, + 32u8, 105u8, 110u8, 116u8, 101u8, 114u8, 99u8, 104u8, 97u8, 110u8, 103u8, + 101u8, 32u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 10u8, 32u8, 67u8, + 111u8, 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, 116u8, 32u8, 50u8, 48u8, + 48u8, 56u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 32u8, 73u8, 110u8, + 99u8, 46u8, 32u8, 32u8, 65u8, 108u8, 108u8, 32u8, 114u8, 105u8, 103u8, 104u8, + 116u8, 115u8, 32u8, 114u8, 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, + 46u8, 10u8, 32u8, 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, 100u8, + 101u8, 118u8, 101u8, 108u8, 111u8, 112u8, 101u8, 114u8, 115u8, 46u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 99u8, 111u8, 109u8, 47u8, 112u8, + 114u8, 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 45u8, 98u8, 117u8, 102u8, + 102u8, 101u8, 114u8, 115u8, 47u8, 10u8, 10u8, 32u8, 82u8, 101u8, 100u8, + 105u8, 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 117u8, 115u8, 101u8, 32u8, 105u8, 110u8, + 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 110u8, 100u8, + 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 115u8, 44u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 111u8, 114u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 10u8, 32u8, 109u8, + 111u8, 100u8, 105u8, 102u8, 105u8, 99u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 44u8, 32u8, 97u8, 114u8, 101u8, 32u8, 112u8, 101u8, 114u8, 109u8, 105u8, + 116u8, 116u8, 101u8, 100u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, + 101u8, 100u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, + 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, + 97u8, 114u8, 101u8, 10u8, 32u8, 109u8, 101u8, 116u8, 58u8, 10u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, + 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 111u8, + 102u8, 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 99u8, 111u8, + 100u8, 101u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 116u8, + 97u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 111u8, + 118u8, 101u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, + 116u8, 10u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, 44u8, 32u8, + 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, + 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, + 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, + 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 100u8, 105u8, + 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 46u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 105u8, 110u8, + 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 112u8, 114u8, + 111u8, 100u8, 117u8, 99u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, + 98u8, 111u8, 118u8, 101u8, 10u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, + 105u8, 103u8, 104u8, 116u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, + 44u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, + 32u8, 111u8, 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, + 111u8, 110u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, + 100u8, 105u8, 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 10u8, + 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 100u8, 111u8, 99u8, + 117u8, 109u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 97u8, 110u8, 100u8, 47u8, 111u8, 114u8, 32u8, 111u8, 116u8, 104u8, 101u8, + 114u8, 32u8, 109u8, 97u8, 116u8, 101u8, 114u8, 105u8, 97u8, 108u8, 115u8, + 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 100u8, 105u8, + 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 78u8, 101u8, 105u8, 116u8, + 104u8, 101u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 110u8, 97u8, 109u8, + 101u8, 32u8, 111u8, 102u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 110u8, 111u8, 114u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, 115u8, 32u8, 111u8, 102u8, 32u8, + 105u8, 116u8, 115u8, 10u8, 32u8, 99u8, 111u8, 110u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 111u8, 114u8, 115u8, 32u8, 109u8, 97u8, 121u8, 32u8, + 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, + 101u8, 110u8, 100u8, 111u8, 114u8, 115u8, 101u8, 32u8, 111u8, 114u8, 32u8, + 112u8, 114u8, 111u8, 109u8, 111u8, 116u8, 101u8, 32u8, 112u8, 114u8, 111u8, + 100u8, 117u8, 99u8, 116u8, 115u8, 32u8, 100u8, 101u8, 114u8, 105u8, 118u8, + 101u8, 100u8, 32u8, 102u8, 114u8, 111u8, 109u8, 10u8, 32u8, 116u8, 104u8, + 105u8, 115u8, 32u8, 115u8, 111u8, 102u8, 116u8, 119u8, 97u8, 114u8, 101u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 32u8, 115u8, 112u8, + 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 112u8, 114u8, 105u8, 111u8, + 114u8, 32u8, 119u8, 114u8, 105u8, 116u8, 116u8, 101u8, 110u8, 32u8, 112u8, + 101u8, 114u8, 109u8, 105u8, 115u8, 115u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 10u8, 32u8, 84u8, 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, + 82u8, 69u8, 32u8, 73u8, 83u8, 32u8, 80u8, 82u8, 79u8, 86u8, 73u8, 68u8, 69u8, + 68u8, 32u8, 66u8, 89u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, + 82u8, 73u8, 71u8, 72u8, 84u8, 32u8, 72u8, 79u8, 76u8, 68u8, 69u8, 82u8, 83u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, + 84u8, 79u8, 82u8, 83u8, 10u8, 32u8, 34u8, 65u8, 83u8, 32u8, 73u8, 83u8, 34u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 65u8, 78u8, 89u8, 32u8, 69u8, 88u8, 80u8, 82u8, + 69u8, 83u8, 83u8, 32u8, 79u8, 82u8, 32u8, 73u8, 77u8, 80u8, 76u8, 73u8, 69u8, + 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, 73u8, 69u8, 83u8, 44u8, + 32u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, 44u8, 32u8, 66u8, + 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, 76u8, 73u8, 77u8, 73u8, 84u8, + 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 84u8, 72u8, 69u8, 32u8, 73u8, 77u8, + 80u8, 76u8, 73u8, 69u8, 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, + 73u8, 69u8, 83u8, 32u8, 79u8, 70u8, 32u8, 77u8, 69u8, 82u8, 67u8, 72u8, 65u8, + 78u8, 84u8, 65u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 65u8, 78u8, 68u8, + 32u8, 70u8, 73u8, 84u8, 78u8, 69u8, 83u8, 83u8, 32u8, 70u8, 79u8, 82u8, 10u8, + 32u8, 65u8, 32u8, 80u8, 65u8, 82u8, 84u8, 73u8, 67u8, 85u8, 76u8, 65u8, 82u8, + 32u8, 80u8, 85u8, 82u8, 80u8, 79u8, 83u8, 69u8, 32u8, 65u8, 82u8, 69u8, 32u8, + 68u8, 73u8, 83u8, 67u8, 76u8, 65u8, 73u8, 77u8, 69u8, 68u8, 46u8, 32u8, 73u8, + 78u8, 32u8, 78u8, 79u8, 32u8, 69u8, 86u8, 69u8, 78u8, 84u8, 32u8, 83u8, 72u8, + 65u8, 76u8, 76u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, 82u8, + 73u8, 71u8, 72u8, 84u8, 10u8, 32u8, 79u8, 87u8, 78u8, 69u8, 82u8, 32u8, 79u8, + 82u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, 84u8, 79u8, 82u8, + 83u8, 32u8, 66u8, 69u8, 32u8, 76u8, 73u8, 65u8, 66u8, 76u8, 69u8, 32u8, 70u8, + 79u8, 82u8, 32u8, 65u8, 78u8, 89u8, 32u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, + 44u8, 32u8, 73u8, 78u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, 44u8, 32u8, 73u8, + 78u8, 67u8, 73u8, 68u8, 69u8, 78u8, 84u8, 65u8, 76u8, 44u8, 10u8, 32u8, 83u8, + 80u8, 69u8, 67u8, 73u8, 65u8, 76u8, 44u8, 32u8, 69u8, 88u8, 69u8, 77u8, 80u8, + 76u8, 65u8, 82u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 67u8, 79u8, 78u8, 83u8, + 69u8, 81u8, 85u8, 69u8, 78u8, 84u8, 73u8, 65u8, 76u8, 32u8, 68u8, 65u8, 77u8, + 65u8, 71u8, 69u8, 83u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, + 78u8, 71u8, 44u8, 32u8, 66u8, 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, + 76u8, 73u8, 77u8, 73u8, 84u8, 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 80u8, + 82u8, 79u8, 67u8, 85u8, 82u8, 69u8, 77u8, 69u8, 78u8, 84u8, 32u8, 79u8, 70u8, + 32u8, 83u8, 85u8, 66u8, 83u8, 84u8, 73u8, 84u8, 85u8, 84u8, 69u8, 32u8, 71u8, + 79u8, 79u8, 68u8, 83u8, 32u8, 79u8, 82u8, 32u8, 83u8, 69u8, 82u8, 86u8, 73u8, + 67u8, 69u8, 83u8, 59u8, 32u8, 76u8, 79u8, 83u8, 83u8, 32u8, 79u8, 70u8, 32u8, + 85u8, 83u8, 69u8, 44u8, 10u8, 32u8, 68u8, 65u8, 84u8, 65u8, 44u8, 32u8, 79u8, + 82u8, 32u8, 80u8, 82u8, 79u8, 70u8, 73u8, 84u8, 83u8, 59u8, 32u8, 79u8, 82u8, + 32u8, 66u8, 85u8, 83u8, 73u8, 78u8, 69u8, 83u8, 83u8, 32u8, 73u8, 78u8, 84u8, + 69u8, 82u8, 82u8, 85u8, 80u8, 84u8, 73u8, 79u8, 78u8, 41u8, 32u8, 72u8, 79u8, + 87u8, 69u8, 86u8, 69u8, 82u8, 32u8, 67u8, 65u8, 85u8, 83u8, 69u8, 68u8, 32u8, + 65u8, 78u8, 68u8, 32u8, 79u8, 78u8, 32u8, 65u8, 78u8, 89u8, 10u8, 32u8, 84u8, + 72u8, 69u8, 79u8, 82u8, 89u8, 32u8, 79u8, 70u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 87u8, 72u8, 69u8, 84u8, 72u8, 69u8, + 82u8, 32u8, 73u8, 78u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 65u8, 67u8, 84u8, + 44u8, 32u8, 83u8, 84u8, 82u8, 73u8, 67u8, 84u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 84u8, 79u8, 82u8, + 84u8, 10u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, + 32u8, 78u8, 69u8, 71u8, 76u8, 73u8, 71u8, 69u8, 78u8, 67u8, 69u8, 32u8, 79u8, + 82u8, 32u8, 79u8, 84u8, 72u8, 69u8, 82u8, 87u8, 73u8, 83u8, 69u8, 41u8, 32u8, + 65u8, 82u8, 73u8, 83u8, 73u8, 78u8, 71u8, 32u8, 73u8, 78u8, 32u8, 65u8, 78u8, + 89u8, 32u8, 87u8, 65u8, 89u8, 32u8, 79u8, 85u8, 84u8, 32u8, 79u8, 70u8, 32u8, + 84u8, 72u8, 69u8, 32u8, 85u8, 83u8, 69u8, 10u8, 32u8, 79u8, 70u8, 32u8, 84u8, + 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, 82u8, 69u8, 44u8, + 32u8, 69u8, 86u8, 69u8, 78u8, 32u8, 73u8, 70u8, 32u8, 65u8, 68u8, 86u8, 73u8, + 83u8, 69u8, 68u8, 32u8, 79u8, 70u8, 32u8, 84u8, 72u8, 69u8, 32u8, 80u8, 79u8, + 83u8, 83u8, 73u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 79u8, 70u8, 32u8, + 83u8, 85u8, 67u8, 72u8, 32u8, 68u8, 65u8, 77u8, 65u8, 71u8, 69u8, 46u8, 10u8, + 10u8, 8u8, 10u8, 1u8, 2u8, 18u8, 3u8, 32u8, 0u8, 24u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 34u8, 0u8, 44u8, 10u8, 9u8, 10u8, 2u8, 8u8, 1u8, 18u8, 3u8, + 34u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 35u8, 0u8, 47u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 8u8, 18u8, 3u8, 35u8, 0u8, 47u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 36u8, 0u8, 34u8, 10u8, 9u8, 10u8, 2u8, 8u8, 10u8, 18u8, 3u8, + 36u8, 0u8, 34u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 37u8, 0u8, 33u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 36u8, 18u8, 3u8, 37u8, 0u8, 33u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 38u8, 0u8, 59u8, 10u8, 9u8, 10u8, 2u8, 8u8, 37u8, 18u8, 3u8, + 38u8, 0u8, 59u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 39u8, 0u8, 73u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 11u8, 18u8, 3u8, 39u8, 0u8, 73u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 40u8, 0u8, 31u8, 10u8, 9u8, 10u8, 2u8, 8u8, 31u8, 18u8, 3u8, + 40u8, 0u8, 31u8, 10u8, 178u8, 44u8, 10u8, 2u8, 4u8, 0u8, 18u8, 6u8, 241u8, + 1u8, 0u8, 244u8, 1u8, 1u8, 26u8, 163u8, 44u8, 32u8, 96u8, 70u8, 105u8, 101u8, + 108u8, 100u8, 77u8, 97u8, 115u8, 107u8, 96u8, 32u8, 114u8, 101u8, 112u8, + 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, 32u8, 115u8, + 101u8, 116u8, 32u8, 111u8, 102u8, 32u8, 115u8, 121u8, 109u8, 98u8, 111u8, + 108u8, 105u8, 99u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 112u8, + 97u8, 116u8, 104u8, 115u8, 44u8, 32u8, 102u8, 111u8, 114u8, 32u8, 101u8, + 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 112u8, 97u8, 116u8, 104u8, 115u8, 58u8, 32u8, 34u8, 102u8, 46u8, + 97u8, 34u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 112u8, 97u8, 116u8, 104u8, + 115u8, 58u8, 32u8, 34u8, 102u8, 46u8, 98u8, 46u8, 100u8, 34u8, 10u8, 10u8, + 32u8, 72u8, 101u8, 114u8, 101u8, 32u8, 96u8, 102u8, 96u8, 32u8, 114u8, 101u8, + 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, 32u8, + 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 105u8, 110u8, 32u8, 115u8, 111u8, + 109u8, 101u8, 32u8, 114u8, 111u8, 111u8, 116u8, 32u8, 109u8, 101u8, 115u8, + 115u8, 97u8, 103u8, 101u8, 44u8, 32u8, 96u8, 97u8, 96u8, 32u8, 97u8, 110u8, + 100u8, 32u8, 96u8, 98u8, 96u8, 10u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 115u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 109u8, 101u8, + 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 102u8, 111u8, 117u8, 110u8, 100u8, + 32u8, 105u8, 110u8, 32u8, 96u8, 102u8, 96u8, 44u8, 32u8, 97u8, 110u8, 100u8, + 32u8, 96u8, 100u8, 96u8, 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 32u8, 102u8, 111u8, 117u8, 110u8, 100u8, 32u8, 105u8, 110u8, 32u8, 116u8, + 104u8, 101u8, 10u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 105u8, 110u8, 32u8, 96u8, 102u8, 46u8, 98u8, 96u8, 46u8, 10u8, 10u8, + 32u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, + 115u8, 32u8, 97u8, 114u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, + 116u8, 111u8, 32u8, 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 121u8, 32u8, + 97u8, 32u8, 115u8, 117u8, 98u8, 115u8, 101u8, 116u8, 32u8, 111u8, 102u8, + 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 116u8, 104u8, 97u8, + 116u8, 32u8, 115u8, 104u8, 111u8, 117u8, 108u8, 100u8, 32u8, 98u8, 101u8, + 10u8, 32u8, 114u8, 101u8, 116u8, 117u8, 114u8, 110u8, 101u8, 100u8, 32u8, + 98u8, 121u8, 32u8, 97u8, 32u8, 103u8, 101u8, 116u8, 32u8, 111u8, 112u8, + 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 111u8, 114u8, 32u8, + 109u8, 111u8, 100u8, 105u8, 102u8, 105u8, 101u8, 100u8, 32u8, 98u8, 121u8, + 32u8, 97u8, 110u8, 32u8, 117u8, 112u8, 100u8, 97u8, 116u8, 101u8, 32u8, + 111u8, 112u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 32u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, + 115u8, 32u8, 97u8, 108u8, 115u8, 111u8, 32u8, 104u8, 97u8, 118u8, 101u8, + 32u8, 97u8, 32u8, 99u8, 117u8, 115u8, 116u8, 111u8, 109u8, 32u8, 74u8, 83u8, + 79u8, 78u8, 32u8, 101u8, 110u8, 99u8, 111u8, 100u8, 105u8, 110u8, 103u8, + 32u8, 40u8, 115u8, 101u8, 101u8, 32u8, 98u8, 101u8, 108u8, 111u8, 119u8, + 41u8, 46u8, 10u8, 10u8, 32u8, 35u8, 32u8, 70u8, 105u8, 101u8, 108u8, 100u8, + 32u8, 77u8, 97u8, 115u8, 107u8, 115u8, 32u8, 105u8, 110u8, 32u8, 80u8, 114u8, + 111u8, 106u8, 101u8, 99u8, 116u8, 105u8, 111u8, 110u8, 115u8, 10u8, 10u8, + 32u8, 87u8, 104u8, 101u8, 110u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 99u8, 111u8, 110u8, 116u8, + 101u8, 120u8, 116u8, 32u8, 111u8, 102u8, 32u8, 97u8, 32u8, 112u8, 114u8, + 111u8, 106u8, 101u8, 99u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, 97u8, + 32u8, 114u8, 101u8, 115u8, 112u8, 111u8, 110u8, 115u8, 101u8, 32u8, 109u8, + 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 111u8, 114u8, 10u8, 32u8, + 115u8, 117u8, 98u8, 45u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 105u8, 115u8, 32u8, 102u8, 105u8, 108u8, 116u8, 101u8, 114u8, 101u8, + 100u8, 32u8, 98u8, 121u8, 32u8, 116u8, 104u8, 101u8, 32u8, 65u8, 80u8, 73u8, + 32u8, 116u8, 111u8, 32u8, 111u8, 110u8, 108u8, 121u8, 32u8, 99u8, 111u8, + 110u8, 116u8, 97u8, 105u8, 110u8, 32u8, 116u8, 104u8, 111u8, 115u8, 101u8, + 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 97u8, 115u8, 10u8, + 32u8, 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 105u8, 101u8, 100u8, 32u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 109u8, 97u8, 115u8, 107u8, + 46u8, 32u8, 70u8, 111u8, 114u8, 32u8, 101u8, 120u8, 97u8, 109u8, 112u8, + 108u8, 101u8, 44u8, 32u8, 105u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 109u8, 97u8, 115u8, 107u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 112u8, 114u8, 101u8, 118u8, 105u8, 111u8, 117u8, 115u8, 10u8, 32u8, + 101u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 105u8, 115u8, 32u8, + 97u8, 112u8, 112u8, 108u8, 105u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, + 97u8, 32u8, 114u8, 101u8, 115u8, 112u8, 111u8, 110u8, 115u8, 101u8, 32u8, + 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 97u8, 115u8, 32u8, + 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 115u8, 58u8, 10u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 102u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 97u8, 32u8, 58u8, 32u8, 50u8, 50u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 98u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 100u8, 32u8, 58u8, 32u8, 49u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 120u8, 32u8, 58u8, 32u8, + 50u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 121u8, 32u8, 58u8, 32u8, 49u8, 51u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 122u8, 58u8, 32u8, 56u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, + 114u8, 101u8, 115u8, 117u8, 108u8, 116u8, 32u8, 119u8, 105u8, 108u8, 108u8, + 32u8, 110u8, 111u8, 116u8, 32u8, 99u8, 111u8, 110u8, 116u8, 97u8, 105u8, + 110u8, 32u8, 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, + 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, 32u8, 102u8, 111u8, 114u8, 32u8, + 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 120u8, 44u8, 121u8, 32u8, + 97u8, 110u8, 100u8, 32u8, 122u8, 10u8, 32u8, 40u8, 116u8, 104u8, 101u8, + 105u8, 114u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 32u8, 119u8, 105u8, + 108u8, 108u8, 32u8, 98u8, 101u8, 32u8, 115u8, 101u8, 116u8, 32u8, 116u8, + 111u8, 32u8, 116u8, 104u8, 101u8, 32u8, 100u8, 101u8, 102u8, 97u8, 117u8, + 108u8, 116u8, 44u8, 32u8, 97u8, 110u8, 100u8, 32u8, 111u8, 109u8, 105u8, + 116u8, 116u8, 101u8, 100u8, 32u8, 105u8, 110u8, 32u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 32u8, 116u8, 101u8, 120u8, 116u8, 10u8, 32u8, 111u8, 117u8, + 116u8, 112u8, 117u8, 116u8, 41u8, 58u8, 10u8, 10u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 102u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 97u8, 32u8, 58u8, 32u8, 50u8, 50u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 98u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 100u8, 32u8, 58u8, 32u8, 49u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, + 10u8, 10u8, 32u8, 65u8, 32u8, 114u8, 101u8, 112u8, 101u8, 97u8, 116u8, 101u8, + 100u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 105u8, 115u8, 32u8, + 110u8, 111u8, 116u8, 32u8, 97u8, 108u8, 108u8, 111u8, 119u8, 101u8, 100u8, + 32u8, 101u8, 120u8, 99u8, 101u8, 112u8, 116u8, 32u8, 97u8, 116u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 108u8, 97u8, 115u8, 116u8, 32u8, 112u8, 111u8, + 115u8, 105u8, 116u8, 105u8, 111u8, 110u8, 32u8, 111u8, 102u8, 32u8, 97u8, + 10u8, 32u8, 112u8, 97u8, 116u8, 104u8, 115u8, 32u8, 115u8, 116u8, 114u8, + 105u8, 110u8, 103u8, 46u8, 10u8, 10u8, 32u8, 73u8, 102u8, 32u8, 97u8, 32u8, + 70u8, 105u8, 101u8, 108u8, 100u8, 77u8, 97u8, 115u8, 107u8, 32u8, 111u8, + 98u8, 106u8, 101u8, 99u8, 116u8, 32u8, 105u8, 115u8, 32u8, 110u8, 111u8, + 116u8, 32u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 32u8, 105u8, + 110u8, 32u8, 97u8, 32u8, 103u8, 101u8, 116u8, 32u8, 111u8, 112u8, 101u8, + 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, 116u8, 104u8, 101u8, + 10u8, 32u8, 111u8, 112u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 32u8, 97u8, 112u8, 112u8, 108u8, 105u8, 101u8, 115u8, 32u8, 116u8, 111u8, + 32u8, 97u8, 108u8, 108u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, + 32u8, 40u8, 97u8, 115u8, 32u8, 105u8, 102u8, 32u8, 97u8, 32u8, 70u8, 105u8, + 101u8, 108u8, 100u8, 77u8, 97u8, 115u8, 107u8, 32u8, 111u8, 102u8, 32u8, + 97u8, 108u8, 108u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 10u8, + 32u8, 104u8, 97u8, 100u8, 32u8, 98u8, 101u8, 101u8, 110u8, 32u8, 115u8, + 112u8, 101u8, 99u8, 105u8, 102u8, 105u8, 101u8, 100u8, 41u8, 46u8, 10u8, + 10u8, 32u8, 78u8, 111u8, 116u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, + 97u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, + 107u8, 32u8, 100u8, 111u8, 101u8, 115u8, 32u8, 110u8, 111u8, 116u8, 32u8, + 110u8, 101u8, 99u8, 101u8, 115u8, 115u8, 97u8, 114u8, 105u8, 108u8, 121u8, + 32u8, 97u8, 112u8, 112u8, 108u8, 121u8, 32u8, 116u8, 111u8, 32u8, 116u8, + 104u8, 101u8, 10u8, 32u8, 116u8, 111u8, 112u8, 45u8, 108u8, 101u8, 118u8, + 101u8, 108u8, 32u8, 114u8, 101u8, 115u8, 112u8, 111u8, 110u8, 115u8, 101u8, + 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 46u8, 32u8, 73u8, + 110u8, 32u8, 99u8, 97u8, 115u8, 101u8, 32u8, 111u8, 102u8, 32u8, 97u8, 32u8, + 82u8, 69u8, 83u8, 84u8, 32u8, 103u8, 101u8, 116u8, 32u8, 111u8, 112u8, 101u8, + 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, 116u8, 104u8, 101u8, + 10u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, + 107u8, 32u8, 97u8, 112u8, 112u8, 108u8, 105u8, 101u8, 115u8, 32u8, 100u8, + 105u8, 114u8, 101u8, 99u8, 116u8, 108u8, 121u8, 32u8, 116u8, 111u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 114u8, 101u8, 115u8, 112u8, 111u8, 110u8, 115u8, + 101u8, 44u8, 32u8, 98u8, 117u8, 116u8, 32u8, 105u8, 110u8, 32u8, 99u8, 97u8, + 115u8, 101u8, 32u8, 111u8, 102u8, 32u8, 97u8, 32u8, 82u8, 69u8, 83u8, 84u8, + 10u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, 112u8, 101u8, 114u8, + 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 109u8, 97u8, 115u8, 107u8, 32u8, 105u8, 110u8, 115u8, 116u8, 101u8, 97u8, + 100u8, 32u8, 97u8, 112u8, 112u8, 108u8, 105u8, 101u8, 115u8, 32u8, 116u8, + 111u8, 32u8, 101u8, 97u8, 99u8, 104u8, 32u8, 105u8, 110u8, 100u8, 105u8, + 118u8, 105u8, 100u8, 117u8, 97u8, 108u8, 32u8, 109u8, 101u8, 115u8, 115u8, + 97u8, 103u8, 101u8, 10u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 114u8, 101u8, 116u8, 117u8, 114u8, 110u8, 101u8, 100u8, 32u8, 114u8, + 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 108u8, 105u8, 115u8, + 116u8, 46u8, 32u8, 73u8, 110u8, 32u8, 99u8, 97u8, 115u8, 101u8, 32u8, 111u8, + 102u8, 32u8, 97u8, 32u8, 82u8, 69u8, 83u8, 84u8, 32u8, 99u8, 117u8, 115u8, + 116u8, 111u8, 109u8, 32u8, 109u8, 101u8, 116u8, 104u8, 111u8, 100u8, 44u8, + 10u8, 32u8, 111u8, 116u8, 104u8, 101u8, 114u8, 32u8, 100u8, 101u8, 102u8, + 105u8, 110u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 109u8, 97u8, + 121u8, 32u8, 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 46u8, 32u8, 87u8, + 104u8, 101u8, 114u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 109u8, 97u8, + 115u8, 107u8, 32u8, 97u8, 112u8, 112u8, 108u8, 105u8, 101u8, 115u8, 32u8, + 119u8, 105u8, 108u8, 108u8, 32u8, 98u8, 101u8, 10u8, 32u8, 99u8, 108u8, + 101u8, 97u8, 114u8, 108u8, 121u8, 32u8, 100u8, 111u8, 99u8, 117u8, 109u8, + 101u8, 110u8, 116u8, 101u8, 100u8, 32u8, 116u8, 111u8, 103u8, 101u8, 116u8, + 104u8, 101u8, 114u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 105u8, 116u8, + 115u8, 32u8, 100u8, 101u8, 99u8, 108u8, 97u8, 114u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 65u8, + 80u8, 73u8, 46u8, 32u8, 32u8, 73u8, 110u8, 10u8, 32u8, 97u8, 110u8, 121u8, + 32u8, 99u8, 97u8, 115u8, 101u8, 44u8, 32u8, 116u8, 104u8, 101u8, 32u8, 101u8, + 102u8, 102u8, 101u8, 99u8, 116u8, 32u8, 111u8, 110u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 114u8, 101u8, 116u8, 117u8, 114u8, 110u8, 101u8, 100u8, 32u8, + 114u8, 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 47u8, 114u8, 101u8, + 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 115u8, 32u8, 105u8, 115u8, 32u8, + 114u8, 101u8, 113u8, 117u8, 105u8, 114u8, 101u8, 100u8, 10u8, 32u8, 98u8, + 101u8, 104u8, 97u8, 118u8, 105u8, 111u8, 114u8, 32u8, 102u8, 111u8, 114u8, + 32u8, 65u8, 80u8, 73u8, 115u8, 46u8, 10u8, 10u8, 32u8, 35u8, 32u8, 70u8, + 105u8, 101u8, 108u8, 100u8, 32u8, 77u8, 97u8, 115u8, 107u8, 115u8, 32u8, + 105u8, 110u8, 32u8, 85u8, 112u8, 100u8, 97u8, 116u8, 101u8, 32u8, 79u8, + 112u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 115u8, 10u8, 10u8, + 32u8, 65u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, + 115u8, 107u8, 32u8, 105u8, 110u8, 32u8, 117u8, 112u8, 100u8, 97u8, 116u8, + 101u8, 32u8, 111u8, 112u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 115u8, 32u8, 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 105u8, 101u8, 115u8, + 32u8, 119u8, 104u8, 105u8, 99u8, 104u8, 32u8, 102u8, 105u8, 101u8, 108u8, + 100u8, 115u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, + 116u8, 97u8, 114u8, 103u8, 101u8, 116u8, 101u8, 100u8, 32u8, 114u8, 101u8, + 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 114u8, 101u8, 32u8, + 103u8, 111u8, 105u8, 110u8, 103u8, 32u8, 116u8, 111u8, 32u8, 98u8, 101u8, + 32u8, 117u8, 112u8, 100u8, 97u8, 116u8, 101u8, 100u8, 46u8, 32u8, 84u8, + 104u8, 101u8, 32u8, 65u8, 80u8, 73u8, 32u8, 105u8, 115u8, 32u8, 114u8, 101u8, + 113u8, 117u8, 105u8, 114u8, 101u8, 100u8, 10u8, 32u8, 116u8, 111u8, 32u8, + 111u8, 110u8, 108u8, 121u8, 32u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, + 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 105u8, 101u8, + 108u8, 100u8, 115u8, 32u8, 97u8, 115u8, 32u8, 115u8, 112u8, 101u8, 99u8, + 105u8, 102u8, 105u8, 101u8, 100u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 109u8, 97u8, 115u8, 107u8, 10u8, 32u8, 97u8, 110u8, 100u8, 32u8, + 108u8, 101u8, 97u8, 118u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 111u8, + 116u8, 104u8, 101u8, 114u8, 115u8, 32u8, 117u8, 110u8, 116u8, 111u8, 117u8, + 99u8, 104u8, 101u8, 100u8, 46u8, 32u8, 73u8, 102u8, 32u8, 97u8, 32u8, 114u8, + 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 105u8, 115u8, 32u8, + 112u8, 97u8, 115u8, 115u8, 101u8, 100u8, 32u8, 105u8, 110u8, 32u8, 116u8, + 111u8, 10u8, 32u8, 100u8, 101u8, 115u8, 99u8, 114u8, 105u8, 98u8, 101u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 117u8, 112u8, 100u8, 97u8, 116u8, 101u8, + 100u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, 44u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 65u8, 80u8, 73u8, 32u8, 105u8, 103u8, 110u8, 111u8, + 114u8, 101u8, 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, 118u8, 97u8, 108u8, + 117u8, 101u8, 115u8, 32u8, 111u8, 102u8, 32u8, 97u8, 108u8, 108u8, 10u8, + 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 110u8, 111u8, 116u8, + 32u8, 99u8, 111u8, 118u8, 101u8, 114u8, 101u8, 100u8, 32u8, 98u8, 121u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 109u8, 97u8, 115u8, 107u8, 46u8, 10u8, 10u8, + 32u8, 73u8, 102u8, 32u8, 97u8, 32u8, 114u8, 101u8, 112u8, 101u8, 97u8, 116u8, + 101u8, 100u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 105u8, 115u8, + 32u8, 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 105u8, 101u8, 100u8, 32u8, + 102u8, 111u8, 114u8, 32u8, 97u8, 110u8, 32u8, 117u8, 112u8, 100u8, 97u8, + 116u8, 101u8, 32u8, 111u8, 112u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, + 110u8, 44u8, 32u8, 110u8, 101u8, 119u8, 32u8, 118u8, 97u8, 108u8, 117u8, + 101u8, 115u8, 32u8, 119u8, 105u8, 108u8, 108u8, 10u8, 32u8, 98u8, 101u8, + 32u8, 97u8, 112u8, 112u8, 101u8, 110u8, 100u8, 101u8, 100u8, 32u8, 116u8, + 111u8, 32u8, 116u8, 104u8, 101u8, 32u8, 101u8, 120u8, 105u8, 115u8, 116u8, + 105u8, 110u8, 103u8, 32u8, 114u8, 101u8, 112u8, 101u8, 97u8, 116u8, 101u8, + 100u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 105u8, 110u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 116u8, 97u8, 114u8, 103u8, 101u8, 116u8, 32u8, + 114u8, 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 46u8, 32u8, 78u8, + 111u8, 116u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 10u8, 32u8, 97u8, 32u8, + 114u8, 101u8, 112u8, 101u8, 97u8, 116u8, 101u8, 100u8, 32u8, 102u8, 105u8, + 101u8, 108u8, 100u8, 32u8, 105u8, 115u8, 32u8, 111u8, 110u8, 108u8, 121u8, + 32u8, 97u8, 108u8, 108u8, 111u8, 119u8, 101u8, 100u8, 32u8, 105u8, 110u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 108u8, 97u8, 115u8, 116u8, 32u8, 112u8, + 111u8, 115u8, 105u8, 116u8, 105u8, 111u8, 110u8, 32u8, 111u8, 102u8, 32u8, + 97u8, 32u8, 96u8, 112u8, 97u8, 116u8, 104u8, 115u8, 96u8, 32u8, 115u8, 116u8, + 114u8, 105u8, 110u8, 103u8, 46u8, 10u8, 10u8, 32u8, 73u8, 102u8, 32u8, 97u8, + 32u8, 115u8, 117u8, 98u8, 45u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, + 101u8, 32u8, 105u8, 115u8, 32u8, 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, + 105u8, 101u8, 100u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 108u8, 97u8, 115u8, 116u8, 32u8, 112u8, 111u8, 115u8, 105u8, 116u8, 105u8, + 111u8, 110u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, + 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 102u8, + 111u8, 114u8, 32u8, 97u8, 110u8, 10u8, 32u8, 117u8, 112u8, 100u8, 97u8, + 116u8, 101u8, 32u8, 111u8, 112u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, + 110u8, 44u8, 32u8, 116u8, 104u8, 101u8, 110u8, 32u8, 110u8, 101u8, 119u8, + 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 32u8, 119u8, 105u8, 108u8, 108u8, + 32u8, 98u8, 101u8, 32u8, 109u8, 101u8, 114u8, 103u8, 101u8, 100u8, 32u8, + 105u8, 110u8, 116u8, 111u8, 32u8, 116u8, 104u8, 101u8, 32u8, 101u8, 120u8, + 105u8, 115u8, 116u8, 105u8, 110u8, 103u8, 32u8, 115u8, 117u8, 98u8, 45u8, + 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 10u8, 32u8, 105u8, 110u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 116u8, 97u8, 114u8, 103u8, 101u8, 116u8, + 32u8, 114u8, 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 46u8, 10u8, + 10u8, 32u8, 70u8, 111u8, 114u8, 32u8, 101u8, 120u8, 97u8, 109u8, 112u8, + 108u8, 101u8, 44u8, 32u8, 103u8, 105u8, 118u8, 101u8, 110u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 116u8, 97u8, 114u8, 103u8, 101u8, 116u8, 32u8, 109u8, + 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 102u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 98u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 100u8, 58u8, 32u8, 49u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 120u8, 58u8, 32u8, 50u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 99u8, 58u8, 32u8, 91u8, 49u8, 93u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 125u8, 10u8, 10u8, 32u8, 65u8, 110u8, 100u8, 32u8, 97u8, 110u8, 32u8, 117u8, + 112u8, 100u8, 97u8, 116u8, 101u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, + 103u8, 101u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 102u8, 32u8, + 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 98u8, 32u8, 123u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 100u8, 58u8, + 32u8, 49u8, 48u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 99u8, 58u8, 32u8, 91u8, 50u8, + 93u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 116u8, + 104u8, 101u8, 110u8, 32u8, 105u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, + 105u8, 115u8, 58u8, 10u8, 10u8, 32u8, 32u8, 112u8, 97u8, 116u8, 104u8, 115u8, + 58u8, 32u8, 91u8, 34u8, 102u8, 46u8, 98u8, 34u8, 44u8, 32u8, 34u8, 102u8, + 46u8, 99u8, 34u8, 93u8, 10u8, 10u8, 32u8, 116u8, 104u8, 101u8, 110u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 114u8, 101u8, 115u8, 117u8, 108u8, 116u8, 32u8, + 119u8, 105u8, 108u8, 108u8, 32u8, 98u8, 101u8, 58u8, 10u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 102u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 98u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 100u8, 58u8, 32u8, 49u8, 48u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 120u8, 58u8, 32u8, 50u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 99u8, 58u8, 32u8, 91u8, 49u8, 44u8, 32u8, 50u8, 93u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 65u8, 110u8, 32u8, + 105u8, 109u8, 112u8, 108u8, 101u8, 109u8, 101u8, 110u8, 116u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 32u8, 109u8, 97u8, 121u8, 32u8, 112u8, 114u8, 111u8, + 118u8, 105u8, 100u8, 101u8, 32u8, 111u8, 112u8, 116u8, 105u8, 111u8, 110u8, + 115u8, 32u8, 116u8, 111u8, 32u8, 111u8, 118u8, 101u8, 114u8, 114u8, 105u8, + 100u8, 101u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 100u8, 101u8, 102u8, + 97u8, 117u8, 108u8, 116u8, 32u8, 98u8, 101u8, 104u8, 97u8, 118u8, 105u8, + 111u8, 114u8, 32u8, 102u8, 111u8, 114u8, 10u8, 32u8, 114u8, 101u8, 112u8, + 101u8, 97u8, 116u8, 101u8, 100u8, 32u8, 97u8, 110u8, 100u8, 32u8, 109u8, + 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 102u8, 105u8, 101u8, 108u8, + 100u8, 115u8, 46u8, 10u8, 10u8, 32u8, 73u8, 110u8, 32u8, 111u8, 114u8, 100u8, + 101u8, 114u8, 32u8, 116u8, 111u8, 32u8, 114u8, 101u8, 115u8, 101u8, 116u8, + 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 39u8, 115u8, 32u8, + 118u8, 97u8, 108u8, 117u8, 101u8, 32u8, 116u8, 111u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 100u8, 101u8, 102u8, 97u8, 117u8, 108u8, 116u8, 44u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, + 117u8, 115u8, 116u8, 10u8, 32u8, 98u8, 101u8, 32u8, 105u8, 110u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 97u8, 110u8, + 100u8, 32u8, 115u8, 101u8, 116u8, 32u8, 116u8, 111u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 100u8, 101u8, 102u8, 97u8, 117u8, 108u8, 116u8, 32u8, 118u8, + 97u8, 108u8, 117u8, 101u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 114u8, + 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 46u8, 10u8, 32u8, 72u8, + 101u8, 110u8, 99u8, 101u8, 44u8, 32u8, 105u8, 110u8, 32u8, 111u8, 114u8, + 100u8, 101u8, 114u8, 32u8, 116u8, 111u8, 32u8, 114u8, 101u8, 115u8, 101u8, + 116u8, 32u8, 97u8, 108u8, 108u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 115u8, 32u8, 111u8, 102u8, 32u8, 97u8, 32u8, 114u8, 101u8, 115u8, 111u8, + 117u8, 114u8, 99u8, 101u8, 44u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, + 100u8, 101u8, 32u8, 97u8, 32u8, 100u8, 101u8, 102u8, 97u8, 117u8, 108u8, + 116u8, 10u8, 32u8, 105u8, 110u8, 115u8, 116u8, 97u8, 110u8, 99u8, 101u8, + 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 114u8, 101u8, 115u8, + 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 110u8, 100u8, 32u8, 115u8, + 101u8, 116u8, 32u8, 97u8, 108u8, 108u8, 32u8, 102u8, 105u8, 101u8, 108u8, + 100u8, 115u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 109u8, + 97u8, 115u8, 107u8, 44u8, 32u8, 111u8, 114u8, 32u8, 100u8, 111u8, 10u8, 32u8, + 110u8, 111u8, 116u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, + 32u8, 97u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 97u8, 115u8, 32u8, 100u8, + 101u8, 115u8, 99u8, 114u8, 105u8, 98u8, 101u8, 100u8, 32u8, 98u8, 101u8, + 108u8, 111u8, 119u8, 46u8, 10u8, 10u8, 32u8, 73u8, 102u8, 32u8, 97u8, 32u8, + 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, + 105u8, 115u8, 32u8, 110u8, 111u8, 116u8, 32u8, 112u8, 114u8, 101u8, 115u8, + 101u8, 110u8, 116u8, 32u8, 111u8, 110u8, 32u8, 117u8, 112u8, 100u8, 97u8, + 116u8, 101u8, 44u8, 32u8, 116u8, 104u8, 101u8, 32u8, 111u8, 112u8, 101u8, + 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 97u8, 112u8, 112u8, 108u8, + 105u8, 101u8, 115u8, 32u8, 116u8, 111u8, 10u8, 32u8, 97u8, 108u8, 108u8, + 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 40u8, 97u8, 115u8, + 32u8, 105u8, 102u8, 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 111u8, 102u8, 32u8, 97u8, 108u8, + 108u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 104u8, 97u8, + 115u8, 32u8, 98u8, 101u8, 101u8, 110u8, 32u8, 115u8, 112u8, 101u8, 99u8, + 105u8, 102u8, 105u8, 101u8, 100u8, 41u8, 46u8, 10u8, 32u8, 78u8, 111u8, + 116u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 105u8, 110u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 99u8, + 101u8, 32u8, 111u8, 102u8, 32u8, 115u8, 99u8, 104u8, 101u8, 109u8, 97u8, + 32u8, 101u8, 118u8, 111u8, 108u8, 117u8, 116u8, 105u8, 111u8, 110u8, 44u8, + 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 109u8, 97u8, 121u8, 32u8, 109u8, + 101u8, 97u8, 110u8, 32u8, 116u8, 104u8, 97u8, 116u8, 10u8, 32u8, 102u8, + 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, 99u8, + 108u8, 105u8, 101u8, 110u8, 116u8, 32u8, 100u8, 111u8, 101u8, 115u8, 32u8, + 110u8, 111u8, 116u8, 32u8, 107u8, 110u8, 111u8, 119u8, 32u8, 97u8, 110u8, + 100u8, 32u8, 104u8, 97u8, 115u8, 32u8, 116u8, 104u8, 101u8, 114u8, 101u8, + 102u8, 111u8, 114u8, 101u8, 32u8, 110u8, 111u8, 116u8, 32u8, 102u8, 105u8, + 108u8, 108u8, 101u8, 100u8, 32u8, 105u8, 110u8, 116u8, 111u8, 10u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 114u8, 101u8, 113u8, 117u8, 101u8, 115u8, 116u8, + 32u8, 119u8, 105u8, 108u8, 108u8, 32u8, 98u8, 101u8, 32u8, 114u8, 101u8, + 115u8, 101u8, 116u8, 32u8, 116u8, 111u8, 32u8, 116u8, 104u8, 101u8, 105u8, + 114u8, 32u8, 100u8, 101u8, 102u8, 97u8, 117u8, 108u8, 116u8, 46u8, 32u8, + 73u8, 102u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 105u8, 115u8, 32u8, + 117u8, 110u8, 119u8, 97u8, 110u8, 116u8, 101u8, 100u8, 10u8, 32u8, 98u8, + 101u8, 104u8, 97u8, 118u8, 105u8, 111u8, 114u8, 44u8, 32u8, 97u8, 32u8, + 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 115u8, 101u8, + 114u8, 118u8, 105u8, 99u8, 101u8, 32u8, 109u8, 97u8, 121u8, 32u8, 114u8, + 101u8, 113u8, 117u8, 105u8, 114u8, 101u8, 32u8, 97u8, 32u8, 99u8, 108u8, + 105u8, 101u8, 110u8, 116u8, 32u8, 116u8, 111u8, 32u8, 97u8, 108u8, 119u8, + 97u8, 121u8, 115u8, 32u8, 115u8, 112u8, 101u8, 99u8, 105u8, 102u8, 121u8, + 10u8, 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, + 115u8, 107u8, 44u8, 32u8, 112u8, 114u8, 111u8, 100u8, 117u8, 99u8, 105u8, + 110u8, 103u8, 32u8, 97u8, 110u8, 32u8, 101u8, 114u8, 114u8, 111u8, 114u8, + 32u8, 105u8, 102u8, 32u8, 110u8, 111u8, 116u8, 46u8, 10u8, 10u8, 32u8, 65u8, + 115u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 103u8, 101u8, 116u8, 32u8, + 111u8, 112u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 115u8, 44u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 108u8, 111u8, 99u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 114u8, + 101u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 119u8, 104u8, 105u8, + 99u8, 104u8, 10u8, 32u8, 100u8, 101u8, 115u8, 99u8, 114u8, 105u8, 98u8, + 101u8, 115u8, 32u8, 116u8, 104u8, 101u8, 32u8, 117u8, 112u8, 100u8, 97u8, + 116u8, 101u8, 100u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, 32u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 114u8, 101u8, 113u8, 117u8, + 101u8, 115u8, 116u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 100u8, 101u8, 112u8, 101u8, 110u8, 100u8, 115u8, 32u8, 111u8, 110u8, + 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 111u8, 112u8, 101u8, 114u8, 97u8, + 116u8, 105u8, 111u8, 110u8, 32u8, 107u8, 105u8, 110u8, 100u8, 46u8, 32u8, + 73u8, 110u8, 32u8, 97u8, 110u8, 121u8, 32u8, 99u8, 97u8, 115u8, 101u8, 44u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 101u8, 102u8, 102u8, 101u8, 99u8, 116u8, + 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 105u8, 101u8, + 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 105u8, 115u8, 10u8, + 32u8, 114u8, 101u8, 113u8, 117u8, 105u8, 114u8, 101u8, 100u8, 32u8, 116u8, + 111u8, 32u8, 98u8, 101u8, 32u8, 104u8, 111u8, 110u8, 111u8, 114u8, 101u8, + 100u8, 32u8, 98u8, 121u8, 32u8, 116u8, 104u8, 101u8, 32u8, 65u8, 80u8, 73u8, + 46u8, 10u8, 10u8, 32u8, 35u8, 35u8, 32u8, 67u8, 111u8, 110u8, 115u8, 105u8, + 100u8, 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 102u8, + 111u8, 114u8, 32u8, 72u8, 84u8, 84u8, 80u8, 32u8, 82u8, 69u8, 83u8, 84u8, + 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 72u8, 84u8, 84u8, 80u8, 32u8, + 107u8, 105u8, 110u8, 100u8, 32u8, 111u8, 102u8, 32u8, 97u8, 110u8, 32u8, + 117u8, 112u8, 100u8, 97u8, 116u8, 101u8, 32u8, 111u8, 112u8, 101u8, 114u8, + 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 119u8, 104u8, 105u8, 99u8, 104u8, + 32u8, 117u8, 115u8, 101u8, 115u8, 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, + 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 109u8, 117u8, 115u8, + 116u8, 10u8, 32u8, 98u8, 101u8, 32u8, 115u8, 101u8, 116u8, 32u8, 116u8, + 111u8, 32u8, 80u8, 65u8, 84u8, 67u8, 72u8, 32u8, 105u8, 110u8, 115u8, 116u8, + 101u8, 97u8, 100u8, 32u8, 111u8, 102u8, 32u8, 80u8, 85u8, 84u8, 32u8, 105u8, + 110u8, 32u8, 111u8, 114u8, 100u8, 101u8, 114u8, 32u8, 116u8, 111u8, 32u8, + 115u8, 97u8, 116u8, 105u8, 115u8, 102u8, 121u8, 32u8, 72u8, 84u8, 84u8, 80u8, + 32u8, 115u8, 101u8, 109u8, 97u8, 110u8, 116u8, 105u8, 99u8, 115u8, 10u8, + 32u8, 40u8, 80u8, 85u8, 84u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 111u8, + 110u8, 108u8, 121u8, 32u8, 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, + 32u8, 102u8, 111u8, 114u8, 32u8, 102u8, 117u8, 108u8, 108u8, 32u8, 117u8, + 112u8, 100u8, 97u8, 116u8, 101u8, 115u8, 41u8, 46u8, 10u8, 10u8, 32u8, 35u8, + 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 69u8, 110u8, 99u8, 111u8, 100u8, 105u8, + 110u8, 103u8, 32u8, 111u8, 102u8, 32u8, 70u8, 105u8, 101u8, 108u8, 100u8, + 32u8, 77u8, 97u8, 115u8, 107u8, 115u8, 10u8, 10u8, 32u8, 73u8, 110u8, 32u8, + 74u8, 83u8, 79u8, 78u8, 44u8, 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, 108u8, + 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 105u8, 115u8, 32u8, 101u8, + 110u8, 99u8, 111u8, 100u8, 101u8, 100u8, 32u8, 97u8, 115u8, 32u8, 97u8, 32u8, + 115u8, 105u8, 110u8, 103u8, 108u8, 101u8, 32u8, 115u8, 116u8, 114u8, 105u8, + 110u8, 103u8, 32u8, 119u8, 104u8, 101u8, 114u8, 101u8, 32u8, 112u8, 97u8, + 116u8, 104u8, 115u8, 32u8, 97u8, 114u8, 101u8, 10u8, 32u8, 115u8, 101u8, + 112u8, 97u8, 114u8, 97u8, 116u8, 101u8, 100u8, 32u8, 98u8, 121u8, 32u8, 97u8, + 32u8, 99u8, 111u8, 109u8, 109u8, 97u8, 46u8, 32u8, 70u8, 105u8, 101u8, 108u8, + 100u8, 115u8, 32u8, 110u8, 97u8, 109u8, 101u8, 32u8, 105u8, 110u8, 32u8, + 101u8, 97u8, 99u8, 104u8, 32u8, 112u8, 97u8, 116u8, 104u8, 32u8, 97u8, 114u8, + 101u8, 32u8, 99u8, 111u8, 110u8, 118u8, 101u8, 114u8, 116u8, 101u8, 100u8, + 10u8, 32u8, 116u8, 111u8, 47u8, 102u8, 114u8, 111u8, 109u8, 32u8, 108u8, + 111u8, 119u8, 101u8, 114u8, 45u8, 99u8, 97u8, 109u8, 101u8, 108u8, 32u8, + 110u8, 97u8, 109u8, 105u8, 110u8, 103u8, 32u8, 99u8, 111u8, 110u8, 118u8, + 101u8, 110u8, 116u8, 105u8, 111u8, 110u8, 115u8, 46u8, 10u8, 10u8, 32u8, + 65u8, 115u8, 32u8, 97u8, 110u8, 32u8, 101u8, 120u8, 97u8, 109u8, 112u8, + 108u8, 101u8, 44u8, 32u8, 99u8, 111u8, 110u8, 115u8, 105u8, 100u8, 101u8, + 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, + 119u8, 105u8, 110u8, 103u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, + 101u8, 32u8, 100u8, 101u8, 99u8, 108u8, 97u8, 114u8, 97u8, 116u8, 105u8, + 111u8, 110u8, 115u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 109u8, + 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 80u8, 114u8, 111u8, 102u8, + 105u8, 108u8, 101u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 85u8, 115u8, 101u8, 114u8, 32u8, 117u8, 115u8, 101u8, 114u8, 32u8, + 61u8, 32u8, 49u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 80u8, + 104u8, 111u8, 116u8, 111u8, 32u8, 112u8, 104u8, 111u8, 116u8, 111u8, 32u8, + 61u8, 32u8, 50u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 85u8, 115u8, 101u8, 114u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 32u8, 100u8, + 105u8, 115u8, 112u8, 108u8, 97u8, 121u8, 95u8, 110u8, 97u8, 109u8, 101u8, + 32u8, 61u8, 32u8, 49u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 32u8, 97u8, 100u8, 100u8, 114u8, + 101u8, 115u8, 115u8, 32u8, 61u8, 32u8, 50u8, 59u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 73u8, 110u8, 32u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 32u8, 97u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, + 109u8, 97u8, 115u8, 107u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, 80u8, + 114u8, 111u8, 102u8, 105u8, 108u8, 101u8, 96u8, 32u8, 109u8, 97u8, 121u8, + 32u8, 108u8, 111u8, 111u8, 107u8, 32u8, 97u8, 115u8, 32u8, 115u8, 117u8, + 99u8, 104u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 109u8, 97u8, + 115u8, 107u8, 32u8, 123u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 112u8, 97u8, 116u8, 104u8, 115u8, 58u8, 32u8, 34u8, 117u8, 115u8, 101u8, + 114u8, 46u8, 100u8, 105u8, 115u8, 112u8, 108u8, 97u8, 121u8, 95u8, 110u8, + 97u8, 109u8, 101u8, 34u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 112u8, 97u8, 116u8, 104u8, 115u8, 58u8, 32u8, 34u8, 112u8, 104u8, 111u8, + 116u8, 111u8, 34u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, + 32u8, 73u8, 110u8, 32u8, 74u8, 83u8, 79u8, 78u8, 44u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 115u8, 97u8, 109u8, 101u8, 32u8, 109u8, 97u8, 115u8, 107u8, + 32u8, 105u8, 115u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, + 110u8, 116u8, 101u8, 100u8, 32u8, 97u8, 115u8, 32u8, 98u8, 101u8, 108u8, + 111u8, 119u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 123u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 109u8, 97u8, 115u8, 107u8, 58u8, + 32u8, 34u8, 117u8, 115u8, 101u8, 114u8, 46u8, 100u8, 105u8, 115u8, 112u8, + 108u8, 97u8, 121u8, 78u8, 97u8, 109u8, 101u8, 44u8, 112u8, 104u8, 111u8, + 116u8, 111u8, 34u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, + 32u8, 35u8, 32u8, 70u8, 105u8, 101u8, 108u8, 100u8, 32u8, 77u8, 97u8, 115u8, + 107u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 79u8, 110u8, 101u8, 111u8, + 102u8, 32u8, 70u8, 105u8, 101u8, 108u8, 100u8, 115u8, 10u8, 10u8, 32u8, 70u8, + 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, 115u8, 107u8, 115u8, 32u8, + 116u8, 114u8, 101u8, 97u8, 116u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 115u8, 32u8, 105u8, 110u8, 32u8, 111u8, 110u8, 101u8, 111u8, 102u8, 115u8, + 32u8, 106u8, 117u8, 115u8, 116u8, 32u8, 97u8, 115u8, 32u8, 114u8, 101u8, + 103u8, 117u8, 108u8, 97u8, 114u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 115u8, 46u8, 32u8, 67u8, 111u8, 110u8, 115u8, 105u8, 100u8, 101u8, 114u8, + 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, + 119u8, 105u8, 110u8, 103u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, + 101u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 109u8, 101u8, 115u8, + 115u8, 97u8, 103u8, 101u8, 32u8, 83u8, 97u8, 109u8, 112u8, 108u8, 101u8, + 77u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 123u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 111u8, 110u8, 101u8, 111u8, 102u8, 32u8, 116u8, + 101u8, 115u8, 116u8, 95u8, 111u8, 110u8, 101u8, 111u8, 102u8, 32u8, 123u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 115u8, 116u8, + 114u8, 105u8, 110u8, 103u8, 32u8, 110u8, 97u8, 109u8, 101u8, 32u8, 61u8, + 32u8, 52u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 83u8, 117u8, 98u8, 77u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, + 115u8, 117u8, 98u8, 95u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, + 32u8, 61u8, 32u8, 57u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 125u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 84u8, + 104u8, 101u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, + 115u8, 107u8, 32u8, 99u8, 97u8, 110u8, 32u8, 98u8, 101u8, 58u8, 10u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 123u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 112u8, 97u8, 116u8, 104u8, 115u8, + 58u8, 32u8, 34u8, 110u8, 97u8, 109u8, 101u8, 34u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 125u8, 10u8, 10u8, 32u8, 79u8, 114u8, 58u8, 10u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 109u8, 97u8, 115u8, 107u8, 32u8, 123u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 112u8, 97u8, 116u8, 104u8, 115u8, 58u8, + 32u8, 34u8, 115u8, 117u8, 98u8, 95u8, 109u8, 101u8, 115u8, 115u8, 97u8, + 103u8, 101u8, 34u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 125u8, 10u8, 10u8, + 32u8, 78u8, 111u8, 116u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, + 111u8, 110u8, 101u8, 111u8, 102u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, + 110u8, 97u8, 109u8, 101u8, 115u8, 32u8, 40u8, 34u8, 116u8, 101u8, 115u8, + 116u8, 95u8, 111u8, 110u8, 101u8, 111u8, 102u8, 34u8, 32u8, 105u8, 110u8, + 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 99u8, 97u8, 115u8, 101u8, 41u8, 32u8, + 99u8, 97u8, 110u8, 110u8, 111u8, 116u8, 32u8, 98u8, 101u8, 32u8, 117u8, + 115u8, 101u8, 100u8, 32u8, 105u8, 110u8, 10u8, 32u8, 112u8, 97u8, 116u8, + 104u8, 115u8, 46u8, 10u8, 10u8, 32u8, 35u8, 35u8, 32u8, 70u8, 105u8, 101u8, + 108u8, 100u8, 32u8, 77u8, 97u8, 115u8, 107u8, 32u8, 86u8, 101u8, 114u8, + 105u8, 102u8, 105u8, 99u8, 97u8, 116u8, 105u8, 111u8, 110u8, 10u8, 10u8, + 32u8, 84u8, 104u8, 101u8, 32u8, 105u8, 109u8, 112u8, 108u8, 101u8, 109u8, + 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 111u8, 102u8, + 32u8, 97u8, 110u8, 121u8, 32u8, 65u8, 80u8, 73u8, 32u8, 109u8, 101u8, 116u8, + 104u8, 111u8, 100u8, 32u8, 119u8, 104u8, 105u8, 99u8, 104u8, 32u8, 104u8, + 97u8, 115u8, 32u8, 97u8, 32u8, 70u8, 105u8, 101u8, 108u8, 100u8, 77u8, 97u8, + 115u8, 107u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 102u8, 105u8, 101u8, + 108u8, 100u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, + 114u8, 101u8, 113u8, 117u8, 101u8, 115u8, 116u8, 32u8, 115u8, 104u8, 111u8, + 117u8, 108u8, 100u8, 32u8, 118u8, 101u8, 114u8, 105u8, 102u8, 121u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 105u8, 110u8, 99u8, 108u8, 117u8, 100u8, 101u8, + 100u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 112u8, 97u8, 116u8, + 104u8, 115u8, 44u8, 32u8, 97u8, 110u8, 100u8, 32u8, 114u8, 101u8, 116u8, + 117u8, 114u8, 110u8, 32u8, 97u8, 110u8, 10u8, 32u8, 96u8, 73u8, 78u8, 86u8, + 65u8, 76u8, 73u8, 68u8, 95u8, 65u8, 82u8, 71u8, 85u8, 77u8, 69u8, 78u8, 84u8, + 96u8, 32u8, 101u8, 114u8, 114u8, 111u8, 114u8, 32u8, 105u8, 102u8, 32u8, + 97u8, 110u8, 121u8, 32u8, 112u8, 97u8, 116u8, 104u8, 32u8, 105u8, 115u8, + 32u8, 117u8, 110u8, 109u8, 97u8, 112u8, 112u8, 97u8, 98u8, 108u8, 101u8, + 46u8, 10u8, 10u8, 11u8, 10u8, 3u8, 4u8, 0u8, 1u8, 18u8, 4u8, 241u8, 1u8, 8u8, + 17u8, 10u8, 44u8, 10u8, 4u8, 4u8, 0u8, 2u8, 0u8, 18u8, 4u8, 243u8, 1u8, 2u8, + 28u8, 26u8, 30u8, 32u8, 84u8, 104u8, 101u8, 32u8, 115u8, 101u8, 116u8, 32u8, + 111u8, 102u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 109u8, 97u8, + 115u8, 107u8, 32u8, 112u8, 97u8, 116u8, 104u8, 115u8, 46u8, 10u8, 10u8, 13u8, + 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 4u8, 18u8, 4u8, 243u8, 1u8, 2u8, 10u8, 10u8, + 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 5u8, 18u8, 4u8, 243u8, 1u8, 11u8, 17u8, + 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 1u8, 18u8, 4u8, 243u8, 1u8, 18u8, + 23u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 3u8, 18u8, 4u8, 243u8, 1u8, + 26u8, 27u8, 98u8, 6u8, 112u8, 114u8, 111u8, 116u8, 111u8, 51u8, 10u8, 254u8, + 34u8, 10u8, 28u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 47u8, 112u8, + 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 47u8, 115u8, 116u8, 114u8, + 117u8, 99u8, 116u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 18u8, 15u8, + 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, + 111u8, 98u8, 117u8, 102u8, 34u8, 152u8, 1u8, 10u8, 6u8, 83u8, 116u8, 114u8, + 117u8, 99u8, 116u8, 18u8, 59u8, 10u8, 6u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 115u8, 24u8, 1u8, 32u8, 3u8, 40u8, 11u8, 50u8, 35u8, 46u8, 103u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, + 117u8, 102u8, 46u8, 83u8, 116u8, 114u8, 117u8, 99u8, 116u8, 46u8, 70u8, + 105u8, 101u8, 108u8, 100u8, 115u8, 69u8, 110u8, 116u8, 114u8, 121u8, 82u8, + 6u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 26u8, 81u8, 10u8, 11u8, 70u8, + 105u8, 101u8, 108u8, 100u8, 115u8, 69u8, 110u8, 116u8, 114u8, 121u8, 18u8, + 16u8, 10u8, 3u8, 107u8, 101u8, 121u8, 24u8, 1u8, 32u8, 1u8, 40u8, 9u8, 82u8, + 3u8, 107u8, 101u8, 121u8, 18u8, 44u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, + 101u8, 24u8, 2u8, 32u8, 1u8, 40u8, 11u8, 50u8, 22u8, 46u8, 103u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, + 117u8, 102u8, 46u8, 86u8, 97u8, 108u8, 117u8, 101u8, 82u8, 5u8, 118u8, 97u8, + 108u8, 117u8, 101u8, 58u8, 2u8, 56u8, 1u8, 34u8, 178u8, 2u8, 10u8, 5u8, 86u8, + 97u8, 108u8, 117u8, 101u8, 18u8, 59u8, 10u8, 10u8, 110u8, 117u8, 108u8, + 108u8, 95u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, 1u8, 32u8, 1u8, 40u8, + 14u8, 50u8, 26u8, 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, + 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 78u8, 117u8, + 108u8, 108u8, 86u8, 97u8, 108u8, 117u8, 101u8, 72u8, 0u8, 82u8, 9u8, 110u8, + 117u8, 108u8, 108u8, 86u8, 97u8, 108u8, 117u8, 101u8, 18u8, 35u8, 10u8, 12u8, + 110u8, 117u8, 109u8, 98u8, 101u8, 114u8, 95u8, 118u8, 97u8, 108u8, 117u8, + 101u8, 24u8, 2u8, 32u8, 1u8, 40u8, 1u8, 72u8, 0u8, 82u8, 11u8, 110u8, 117u8, + 109u8, 98u8, 101u8, 114u8, 86u8, 97u8, 108u8, 117u8, 101u8, 18u8, 35u8, 10u8, + 12u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 95u8, 118u8, 97u8, 108u8, + 117u8, 101u8, 24u8, 3u8, 32u8, 1u8, 40u8, 9u8, 72u8, 0u8, 82u8, 11u8, 115u8, + 116u8, 114u8, 105u8, 110u8, 103u8, 86u8, 97u8, 108u8, 117u8, 101u8, 18u8, + 31u8, 10u8, 10u8, 98u8, 111u8, 111u8, 108u8, 95u8, 118u8, 97u8, 108u8, 117u8, + 101u8, 24u8, 4u8, 32u8, 1u8, 40u8, 8u8, 72u8, 0u8, 82u8, 9u8, 98u8, 111u8, + 111u8, 108u8, 86u8, 97u8, 108u8, 117u8, 101u8, 18u8, 60u8, 10u8, 12u8, 115u8, + 116u8, 114u8, 117u8, 99u8, 116u8, 95u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 24u8, 5u8, 32u8, 1u8, 40u8, 11u8, 50u8, 23u8, 46u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 46u8, 83u8, 116u8, 114u8, 117u8, 99u8, 116u8, 72u8, 0u8, 82u8, 11u8, + 115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 86u8, 97u8, 108u8, 117u8, 101u8, + 18u8, 59u8, 10u8, 10u8, 108u8, 105u8, 115u8, 116u8, 95u8, 118u8, 97u8, 108u8, + 117u8, 101u8, 24u8, 6u8, 32u8, 1u8, 40u8, 11u8, 50u8, 26u8, 46u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 98u8, 117u8, 102u8, 46u8, 76u8, 105u8, 115u8, 116u8, 86u8, 97u8, 108u8, + 117u8, 101u8, 72u8, 0u8, 82u8, 9u8, 108u8, 105u8, 115u8, 116u8, 86u8, 97u8, + 108u8, 117u8, 101u8, 66u8, 6u8, 10u8, 4u8, 107u8, 105u8, 110u8, 100u8, 34u8, + 59u8, 10u8, 9u8, 76u8, 105u8, 115u8, 116u8, 86u8, 97u8, 108u8, 117u8, 101u8, + 18u8, 46u8, 10u8, 6u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, 24u8, 1u8, + 32u8, 3u8, 40u8, 11u8, 50u8, 22u8, 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, + 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, + 86u8, 97u8, 108u8, 117u8, 101u8, 82u8, 6u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 115u8, 42u8, 27u8, 10u8, 9u8, 78u8, 117u8, 108u8, 108u8, 86u8, 97u8, 108u8, + 117u8, 101u8, 18u8, 14u8, 10u8, 10u8, 78u8, 85u8, 76u8, 76u8, 95u8, 86u8, + 65u8, 76u8, 85u8, 69u8, 16u8, 0u8, 66u8, 127u8, 10u8, 19u8, 99u8, 111u8, + 109u8, 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 112u8, 114u8, + 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 66u8, 11u8, 83u8, 116u8, 114u8, + 117u8, 99u8, 116u8, 80u8, 114u8, 111u8, 116u8, 111u8, 80u8, 1u8, 90u8, 47u8, + 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 103u8, 111u8, 108u8, 97u8, + 110u8, 103u8, 46u8, 111u8, 114u8, 103u8, 47u8, 112u8, 114u8, 111u8, 116u8, + 111u8, 98u8, 117u8, 102u8, 47u8, 116u8, 121u8, 112u8, 101u8, 115u8, 47u8, + 107u8, 110u8, 111u8, 119u8, 110u8, 47u8, 115u8, 116u8, 114u8, 117u8, 99u8, + 116u8, 112u8, 98u8, 248u8, 1u8, 1u8, 162u8, 2u8, 3u8, 71u8, 80u8, 66u8, + 170u8, 2u8, 30u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 80u8, 114u8, + 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 87u8, 101u8, 108u8, 108u8, + 75u8, 110u8, 111u8, 119u8, 110u8, 84u8, 121u8, 112u8, 101u8, 115u8, 74u8, + 153u8, 29u8, 10u8, 6u8, 18u8, 4u8, 30u8, 0u8, 94u8, 1u8, 10u8, 204u8, 12u8, + 10u8, 1u8, 12u8, 18u8, 3u8, 30u8, 0u8, 18u8, 50u8, 193u8, 12u8, 32u8, 80u8, + 114u8, 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, 66u8, 117u8, 102u8, + 102u8, 101u8, 114u8, 115u8, 32u8, 45u8, 32u8, 71u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 39u8, 115u8, 32u8, 100u8, 97u8, 116u8, 97u8, 32u8, 105u8, + 110u8, 116u8, 101u8, 114u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, 32u8, + 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 10u8, 32u8, 67u8, 111u8, 112u8, + 121u8, 114u8, 105u8, 103u8, 104u8, 116u8, 32u8, 50u8, 48u8, 48u8, 56u8, 32u8, + 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, + 32u8, 65u8, 108u8, 108u8, 32u8, 114u8, 105u8, 103u8, 104u8, 116u8, 115u8, + 32u8, 114u8, 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, 46u8, 10u8, + 32u8, 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, 100u8, 101u8, + 118u8, 101u8, 108u8, 111u8, 112u8, 101u8, 114u8, 115u8, 46u8, 103u8, 111u8, + 111u8, 103u8, 108u8, 101u8, 46u8, 99u8, 111u8, 109u8, 47u8, 112u8, 114u8, + 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 45u8, 98u8, 117u8, 102u8, 102u8, + 101u8, 114u8, 115u8, 47u8, 10u8, 10u8, 32u8, 82u8, 101u8, 100u8, 105u8, + 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 97u8, 110u8, 100u8, 32u8, 117u8, 115u8, 101u8, 32u8, 105u8, 110u8, 32u8, + 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 110u8, 100u8, 32u8, + 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, 109u8, + 115u8, 44u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 111u8, 114u8, 32u8, + 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 10u8, 32u8, 109u8, 111u8, + 100u8, 105u8, 102u8, 105u8, 99u8, 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, + 32u8, 97u8, 114u8, 101u8, 32u8, 112u8, 101u8, 114u8, 109u8, 105u8, 116u8, + 116u8, 101u8, 100u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, + 100u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 116u8, 104u8, 101u8, 32u8, + 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 99u8, + 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 97u8, + 114u8, 101u8, 10u8, 32u8, 109u8, 101u8, 116u8, 58u8, 10u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 111u8, 102u8, + 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 99u8, 111u8, 100u8, + 101u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 116u8, 97u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 111u8, 118u8, + 101u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, 116u8, + 10u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, 44u8, 32u8, 116u8, + 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, 102u8, + 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 111u8, + 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 100u8, 105u8, 115u8, + 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 46u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 105u8, 110u8, + 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 112u8, 114u8, + 111u8, 100u8, 117u8, 99u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, + 98u8, 111u8, 118u8, 101u8, 10u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, + 105u8, 103u8, 104u8, 116u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, + 44u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, + 32u8, 111u8, 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, + 111u8, 110u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, + 100u8, 105u8, 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 10u8, + 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 100u8, 111u8, 99u8, + 117u8, 109u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 97u8, 110u8, 100u8, 47u8, 111u8, 114u8, 32u8, 111u8, 116u8, 104u8, 101u8, + 114u8, 32u8, 109u8, 97u8, 116u8, 101u8, 114u8, 105u8, 97u8, 108u8, 115u8, + 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 100u8, 105u8, + 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 78u8, 101u8, 105u8, 116u8, + 104u8, 101u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 110u8, 97u8, 109u8, + 101u8, 32u8, 111u8, 102u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 110u8, 111u8, 114u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, 115u8, 32u8, 111u8, 102u8, 32u8, + 105u8, 116u8, 115u8, 10u8, 32u8, 99u8, 111u8, 110u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 111u8, 114u8, 115u8, 32u8, 109u8, 97u8, 121u8, 32u8, + 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, + 101u8, 110u8, 100u8, 111u8, 114u8, 115u8, 101u8, 32u8, 111u8, 114u8, 32u8, + 112u8, 114u8, 111u8, 109u8, 111u8, 116u8, 101u8, 32u8, 112u8, 114u8, 111u8, + 100u8, 117u8, 99u8, 116u8, 115u8, 32u8, 100u8, 101u8, 114u8, 105u8, 118u8, + 101u8, 100u8, 32u8, 102u8, 114u8, 111u8, 109u8, 10u8, 32u8, 116u8, 104u8, + 105u8, 115u8, 32u8, 115u8, 111u8, 102u8, 116u8, 119u8, 97u8, 114u8, 101u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 32u8, 115u8, 112u8, + 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 112u8, 114u8, 105u8, 111u8, + 114u8, 32u8, 119u8, 114u8, 105u8, 116u8, 116u8, 101u8, 110u8, 32u8, 112u8, + 101u8, 114u8, 109u8, 105u8, 115u8, 115u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 10u8, 32u8, 84u8, 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, + 82u8, 69u8, 32u8, 73u8, 83u8, 32u8, 80u8, 82u8, 79u8, 86u8, 73u8, 68u8, 69u8, + 68u8, 32u8, 66u8, 89u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, + 82u8, 73u8, 71u8, 72u8, 84u8, 32u8, 72u8, 79u8, 76u8, 68u8, 69u8, 82u8, 83u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, + 84u8, 79u8, 82u8, 83u8, 10u8, 32u8, 34u8, 65u8, 83u8, 32u8, 73u8, 83u8, 34u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 65u8, 78u8, 89u8, 32u8, 69u8, 88u8, 80u8, 82u8, + 69u8, 83u8, 83u8, 32u8, 79u8, 82u8, 32u8, 73u8, 77u8, 80u8, 76u8, 73u8, 69u8, + 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, 73u8, 69u8, 83u8, 44u8, + 32u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, 44u8, 32u8, 66u8, + 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, 76u8, 73u8, 77u8, 73u8, 84u8, + 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 84u8, 72u8, 69u8, 32u8, 73u8, 77u8, + 80u8, 76u8, 73u8, 69u8, 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, + 73u8, 69u8, 83u8, 32u8, 79u8, 70u8, 32u8, 77u8, 69u8, 82u8, 67u8, 72u8, 65u8, + 78u8, 84u8, 65u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 65u8, 78u8, 68u8, + 32u8, 70u8, 73u8, 84u8, 78u8, 69u8, 83u8, 83u8, 32u8, 70u8, 79u8, 82u8, 10u8, + 32u8, 65u8, 32u8, 80u8, 65u8, 82u8, 84u8, 73u8, 67u8, 85u8, 76u8, 65u8, 82u8, + 32u8, 80u8, 85u8, 82u8, 80u8, 79u8, 83u8, 69u8, 32u8, 65u8, 82u8, 69u8, 32u8, + 68u8, 73u8, 83u8, 67u8, 76u8, 65u8, 73u8, 77u8, 69u8, 68u8, 46u8, 32u8, 73u8, + 78u8, 32u8, 78u8, 79u8, 32u8, 69u8, 86u8, 69u8, 78u8, 84u8, 32u8, 83u8, 72u8, + 65u8, 76u8, 76u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, 82u8, + 73u8, 71u8, 72u8, 84u8, 10u8, 32u8, 79u8, 87u8, 78u8, 69u8, 82u8, 32u8, 79u8, + 82u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, 84u8, 79u8, 82u8, + 83u8, 32u8, 66u8, 69u8, 32u8, 76u8, 73u8, 65u8, 66u8, 76u8, 69u8, 32u8, 70u8, + 79u8, 82u8, 32u8, 65u8, 78u8, 89u8, 32u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, + 44u8, 32u8, 73u8, 78u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, 44u8, 32u8, 73u8, + 78u8, 67u8, 73u8, 68u8, 69u8, 78u8, 84u8, 65u8, 76u8, 44u8, 10u8, 32u8, 83u8, + 80u8, 69u8, 67u8, 73u8, 65u8, 76u8, 44u8, 32u8, 69u8, 88u8, 69u8, 77u8, 80u8, + 76u8, 65u8, 82u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 67u8, 79u8, 78u8, 83u8, + 69u8, 81u8, 85u8, 69u8, 78u8, 84u8, 73u8, 65u8, 76u8, 32u8, 68u8, 65u8, 77u8, + 65u8, 71u8, 69u8, 83u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, + 78u8, 71u8, 44u8, 32u8, 66u8, 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, + 76u8, 73u8, 77u8, 73u8, 84u8, 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 80u8, + 82u8, 79u8, 67u8, 85u8, 82u8, 69u8, 77u8, 69u8, 78u8, 84u8, 32u8, 79u8, 70u8, + 32u8, 83u8, 85u8, 66u8, 83u8, 84u8, 73u8, 84u8, 85u8, 84u8, 69u8, 32u8, 71u8, + 79u8, 79u8, 68u8, 83u8, 32u8, 79u8, 82u8, 32u8, 83u8, 69u8, 82u8, 86u8, 73u8, + 67u8, 69u8, 83u8, 59u8, 32u8, 76u8, 79u8, 83u8, 83u8, 32u8, 79u8, 70u8, 32u8, + 85u8, 83u8, 69u8, 44u8, 10u8, 32u8, 68u8, 65u8, 84u8, 65u8, 44u8, 32u8, 79u8, + 82u8, 32u8, 80u8, 82u8, 79u8, 70u8, 73u8, 84u8, 83u8, 59u8, 32u8, 79u8, 82u8, + 32u8, 66u8, 85u8, 83u8, 73u8, 78u8, 69u8, 83u8, 83u8, 32u8, 73u8, 78u8, 84u8, + 69u8, 82u8, 82u8, 85u8, 80u8, 84u8, 73u8, 79u8, 78u8, 41u8, 32u8, 72u8, 79u8, + 87u8, 69u8, 86u8, 69u8, 82u8, 32u8, 67u8, 65u8, 85u8, 83u8, 69u8, 68u8, 32u8, + 65u8, 78u8, 68u8, 32u8, 79u8, 78u8, 32u8, 65u8, 78u8, 89u8, 10u8, 32u8, 84u8, + 72u8, 69u8, 79u8, 82u8, 89u8, 32u8, 79u8, 70u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 87u8, 72u8, 69u8, 84u8, 72u8, 69u8, + 82u8, 32u8, 73u8, 78u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 65u8, 67u8, 84u8, + 44u8, 32u8, 83u8, 84u8, 82u8, 73u8, 67u8, 84u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 84u8, 79u8, 82u8, + 84u8, 10u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, + 32u8, 78u8, 69u8, 71u8, 76u8, 73u8, 71u8, 69u8, 78u8, 67u8, 69u8, 32u8, 79u8, + 82u8, 32u8, 79u8, 84u8, 72u8, 69u8, 82u8, 87u8, 73u8, 83u8, 69u8, 41u8, 32u8, + 65u8, 82u8, 73u8, 83u8, 73u8, 78u8, 71u8, 32u8, 73u8, 78u8, 32u8, 65u8, 78u8, + 89u8, 32u8, 87u8, 65u8, 89u8, 32u8, 79u8, 85u8, 84u8, 32u8, 79u8, 70u8, 32u8, + 84u8, 72u8, 69u8, 32u8, 85u8, 83u8, 69u8, 10u8, 32u8, 79u8, 70u8, 32u8, 84u8, + 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, 82u8, 69u8, 44u8, + 32u8, 69u8, 86u8, 69u8, 78u8, 32u8, 73u8, 70u8, 32u8, 65u8, 68u8, 86u8, 73u8, + 83u8, 69u8, 68u8, 32u8, 79u8, 70u8, 32u8, 84u8, 72u8, 69u8, 32u8, 80u8, 79u8, + 83u8, 83u8, 73u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 79u8, 70u8, 32u8, + 83u8, 85u8, 67u8, 72u8, 32u8, 68u8, 65u8, 77u8, 65u8, 71u8, 69u8, 46u8, 10u8, + 10u8, 8u8, 10u8, 1u8, 2u8, 18u8, 3u8, 32u8, 0u8, 24u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 34u8, 0u8, 31u8, 10u8, 9u8, 10u8, 2u8, 8u8, 31u8, 18u8, 3u8, + 34u8, 0u8, 31u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 35u8, 0u8, 70u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 11u8, 18u8, 3u8, 35u8, 0u8, 70u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 36u8, 0u8, 44u8, 10u8, 9u8, 10u8, 2u8, 8u8, 1u8, 18u8, 3u8, + 36u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 37u8, 0u8, 44u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 8u8, 18u8, 3u8, 37u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 38u8, 0u8, 34u8, 10u8, 9u8, 10u8, 2u8, 8u8, 10u8, 18u8, 3u8, + 38u8, 0u8, 34u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 39u8, 0u8, 33u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 36u8, 18u8, 3u8, 39u8, 0u8, 33u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 40u8, 0u8, 59u8, 10u8, 9u8, 10u8, 2u8, 8u8, 37u8, 18u8, 3u8, + 40u8, 0u8, 59u8, 10u8, 179u8, 3u8, 10u8, 2u8, 4u8, 0u8, 18u8, 4u8, 50u8, 0u8, + 53u8, 1u8, 26u8, 166u8, 3u8, 32u8, 96u8, 83u8, 116u8, 114u8, 117u8, 99u8, + 116u8, 96u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, + 116u8, 115u8, 32u8, 97u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8, + 117u8, 114u8, 101u8, 100u8, 32u8, 100u8, 97u8, 116u8, 97u8, 32u8, 118u8, + 97u8, 108u8, 117u8, 101u8, 44u8, 32u8, 99u8, 111u8, 110u8, 115u8, 105u8, + 115u8, 116u8, 105u8, 110u8, 103u8, 32u8, 111u8, 102u8, 32u8, 102u8, 105u8, + 101u8, 108u8, 100u8, 115u8, 10u8, 32u8, 119u8, 104u8, 105u8, 99u8, 104u8, + 32u8, 109u8, 97u8, 112u8, 32u8, 116u8, 111u8, 32u8, 100u8, 121u8, 110u8, + 97u8, 109u8, 105u8, 99u8, 97u8, 108u8, 108u8, 121u8, 32u8, 116u8, 121u8, + 112u8, 101u8, 100u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, 46u8, + 32u8, 73u8, 110u8, 32u8, 115u8, 111u8, 109u8, 101u8, 32u8, 108u8, 97u8, + 110u8, 103u8, 117u8, 97u8, 103u8, 101u8, 115u8, 44u8, 32u8, 96u8, 83u8, + 116u8, 114u8, 117u8, 99u8, 116u8, 96u8, 10u8, 32u8, 109u8, 105u8, 103u8, + 104u8, 116u8, 32u8, 98u8, 101u8, 32u8, 115u8, 117u8, 112u8, 112u8, 111u8, + 114u8, 116u8, 101u8, 100u8, 32u8, 98u8, 121u8, 32u8, 97u8, 32u8, 110u8, 97u8, + 116u8, 105u8, 118u8, 101u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, + 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 46u8, 32u8, 70u8, + 111u8, 114u8, 32u8, 101u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 44u8, + 32u8, 105u8, 110u8, 10u8, 32u8, 115u8, 99u8, 114u8, 105u8, 112u8, 116u8, + 105u8, 110u8, 103u8, 32u8, 108u8, 97u8, 110u8, 103u8, 117u8, 97u8, 103u8, + 101u8, 115u8, 32u8, 108u8, 105u8, 107u8, 101u8, 32u8, 74u8, 83u8, 32u8, 97u8, + 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8, 32u8, 105u8, 115u8, 32u8, + 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 101u8, 100u8, + 32u8, 97u8, 115u8, 32u8, 97u8, 110u8, 10u8, 32u8, 111u8, 98u8, 106u8, 101u8, + 99u8, 116u8, 46u8, 32u8, 84u8, 104u8, 101u8, 32u8, 100u8, 101u8, 116u8, 97u8, + 105u8, 108u8, 115u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, 97u8, 116u8, + 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, + 116u8, 105u8, 111u8, 110u8, 32u8, 97u8, 114u8, 101u8, 32u8, 100u8, 101u8, + 115u8, 99u8, 114u8, 105u8, 98u8, 101u8, 100u8, 32u8, 116u8, 111u8, 103u8, + 101u8, 116u8, 104u8, 101u8, 114u8, 10u8, 32u8, 119u8, 105u8, 116u8, 104u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 112u8, 114u8, 111u8, 116u8, 111u8, 32u8, + 115u8, 117u8, 112u8, 112u8, 111u8, 114u8, 116u8, 32u8, 102u8, 111u8, 114u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 108u8, 97u8, 110u8, 103u8, 117u8, 97u8, + 103u8, 101u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, + 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, + 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, + 96u8, 83u8, 116u8, 114u8, 117u8, 99u8, 116u8, 96u8, 32u8, 105u8, 115u8, 32u8, + 74u8, 83u8, 79u8, 78u8, 32u8, 111u8, 98u8, 106u8, 101u8, 99u8, 116u8, 46u8, + 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 0u8, 1u8, 18u8, 3u8, 50u8, 8u8, 14u8, 10u8, + 57u8, 10u8, 4u8, 4u8, 0u8, 2u8, 0u8, 18u8, 3u8, 52u8, 2u8, 32u8, 26u8, 44u8, + 32u8, 85u8, 110u8, 111u8, 114u8, 100u8, 101u8, 114u8, 101u8, 100u8, 32u8, + 109u8, 97u8, 112u8, 32u8, 111u8, 102u8, 32u8, 100u8, 121u8, 110u8, 97u8, + 109u8, 105u8, 99u8, 97u8, 108u8, 108u8, 121u8, 32u8, 116u8, 121u8, 112u8, + 101u8, 100u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, 46u8, 10u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 6u8, 18u8, 3u8, 52u8, 2u8, 20u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 1u8, 18u8, 3u8, 52u8, 21u8, 27u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 3u8, 18u8, 3u8, 52u8, 30u8, 31u8, + 10u8, 196u8, 2u8, 10u8, 2u8, 4u8, 1u8, 18u8, 4u8, 61u8, 0u8, 77u8, 1u8, 26u8, + 183u8, 2u8, 32u8, 96u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, 114u8, + 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, + 32u8, 100u8, 121u8, 110u8, 97u8, 109u8, 105u8, 99u8, 97u8, 108u8, 108u8, + 121u8, 32u8, 116u8, 121u8, 112u8, 101u8, 100u8, 32u8, 118u8, 97u8, 108u8, + 117u8, 101u8, 32u8, 119u8, 104u8, 105u8, 99u8, 104u8, 32u8, 99u8, 97u8, + 110u8, 32u8, 98u8, 101u8, 32u8, 101u8, 105u8, 116u8, 104u8, 101u8, 114u8, + 10u8, 32u8, 110u8, 117u8, 108u8, 108u8, 44u8, 32u8, 97u8, 32u8, 110u8, 117u8, + 109u8, 98u8, 101u8, 114u8, 44u8, 32u8, 97u8, 32u8, 115u8, 116u8, 114u8, + 105u8, 110u8, 103u8, 44u8, 32u8, 97u8, 32u8, 98u8, 111u8, 111u8, 108u8, + 101u8, 97u8, 110u8, 44u8, 32u8, 97u8, 32u8, 114u8, 101u8, 99u8, 117u8, 114u8, + 115u8, 105u8, 118u8, 101u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8, + 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 44u8, 32u8, 111u8, 114u8, 32u8, 97u8, + 10u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, 102u8, 32u8, 118u8, + 97u8, 108u8, 117u8, 101u8, 115u8, 46u8, 32u8, 65u8, 32u8, 112u8, 114u8, + 111u8, 100u8, 117u8, 99u8, 101u8, 114u8, 32u8, 111u8, 102u8, 32u8, 118u8, + 97u8, 108u8, 117u8, 101u8, 32u8, 105u8, 115u8, 32u8, 101u8, 120u8, 112u8, + 101u8, 99u8, 116u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, 115u8, 101u8, + 116u8, 32u8, 111u8, 110u8, 101u8, 32u8, 111u8, 102u8, 32u8, 116u8, 104u8, + 101u8, 115u8, 101u8, 10u8, 32u8, 118u8, 97u8, 114u8, 105u8, 97u8, 110u8, + 116u8, 115u8, 46u8, 32u8, 65u8, 98u8, 115u8, 101u8, 110u8, 99u8, 101u8, 32u8, + 111u8, 102u8, 32u8, 97u8, 110u8, 121u8, 32u8, 118u8, 97u8, 114u8, 105u8, + 97u8, 110u8, 116u8, 32u8, 105u8, 110u8, 100u8, 105u8, 99u8, 97u8, 116u8, + 101u8, 115u8, 32u8, 97u8, 110u8, 32u8, 101u8, 114u8, 114u8, 111u8, 114u8, + 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, + 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, + 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, 86u8, + 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, + 78u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 10u8, 10u8, + 3u8, 4u8, 1u8, 1u8, 18u8, 3u8, 61u8, 8u8, 13u8, 10u8, 34u8, 10u8, 4u8, 4u8, + 1u8, 8u8, 0u8, 18u8, 4u8, 63u8, 2u8, 76u8, 3u8, 26u8, 20u8, 32u8, 84u8, + 104u8, 101u8, 32u8, 107u8, 105u8, 110u8, 100u8, 32u8, 111u8, 102u8, 32u8, + 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, + 1u8, 8u8, 0u8, 1u8, 18u8, 3u8, 63u8, 8u8, 12u8, 10u8, 39u8, 10u8, 4u8, 4u8, + 1u8, 2u8, 0u8, 18u8, 3u8, 65u8, 4u8, 29u8, 26u8, 26u8, 32u8, 82u8, 101u8, + 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, 32u8, + 110u8, 117u8, 108u8, 108u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, + 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 0u8, 6u8, 18u8, 3u8, 65u8, 4u8, + 13u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 0u8, 1u8, 18u8, 3u8, 65u8, 14u8, + 24u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 0u8, 3u8, 18u8, 3u8, 65u8, 27u8, + 28u8, 10u8, 41u8, 10u8, 4u8, 4u8, 1u8, 2u8, 1u8, 18u8, 3u8, 67u8, 4u8, 28u8, + 26u8, 28u8, 32u8, 82u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, + 116u8, 115u8, 32u8, 97u8, 32u8, 100u8, 111u8, 117u8, 98u8, 108u8, 101u8, + 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, + 4u8, 1u8, 2u8, 1u8, 5u8, 18u8, 3u8, 67u8, 4u8, 10u8, 10u8, 12u8, 10u8, 5u8, + 4u8, 1u8, 2u8, 1u8, 1u8, 18u8, 3u8, 67u8, 11u8, 23u8, 10u8, 12u8, 10u8, 5u8, + 4u8, 1u8, 2u8, 1u8, 3u8, 18u8, 3u8, 67u8, 26u8, 27u8, 10u8, 41u8, 10u8, 4u8, + 4u8, 1u8, 2u8, 2u8, 18u8, 3u8, 69u8, 4u8, 28u8, 26u8, 28u8, 32u8, 82u8, + 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, + 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 32u8, 118u8, 97u8, 108u8, + 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 2u8, 5u8, + 18u8, 3u8, 69u8, 4u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 2u8, 1u8, + 18u8, 3u8, 69u8, 11u8, 23u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 2u8, 3u8, + 18u8, 3u8, 69u8, 26u8, 27u8, 10u8, 42u8, 10u8, 4u8, 4u8, 1u8, 2u8, 3u8, 18u8, + 3u8, 71u8, 4u8, 24u8, 26u8, 29u8, 32u8, 82u8, 101u8, 112u8, 114u8, 101u8, + 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, 32u8, 98u8, 111u8, 111u8, + 108u8, 101u8, 97u8, 110u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, + 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 3u8, 5u8, 18u8, 3u8, 71u8, 4u8, + 8u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 3u8, 1u8, 18u8, 3u8, 71u8, 9u8, + 19u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 3u8, 3u8, 18u8, 3u8, 71u8, 22u8, + 23u8, 10u8, 45u8, 10u8, 4u8, 4u8, 1u8, 2u8, 4u8, 18u8, 3u8, 73u8, 4u8, 28u8, + 26u8, 32u8, 32u8, 82u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, + 116u8, 115u8, 32u8, 97u8, 32u8, 115u8, 116u8, 114u8, 117u8, 99u8, 116u8, + 117u8, 114u8, 101u8, 100u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, + 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 4u8, 6u8, 18u8, 3u8, 73u8, 4u8, + 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 4u8, 1u8, 18u8, 3u8, 73u8, 11u8, + 23u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 4u8, 3u8, 18u8, 3u8, 73u8, 26u8, + 27u8, 10u8, 45u8, 10u8, 4u8, 4u8, 1u8, 2u8, 5u8, 18u8, 3u8, 75u8, 4u8, 29u8, + 26u8, 32u8, 32u8, 82u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, + 116u8, 115u8, 32u8, 97u8, 32u8, 114u8, 101u8, 112u8, 101u8, 97u8, 116u8, + 101u8, 100u8, 32u8, 96u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 46u8, 10u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 5u8, 6u8, 18u8, 3u8, 75u8, 4u8, 13u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 5u8, 1u8, 18u8, 3u8, 75u8, 14u8, 24u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 5u8, 3u8, 18u8, 3u8, 75u8, 27u8, 28u8, + 10u8, 168u8, 1u8, 10u8, 2u8, 5u8, 0u8, 18u8, 4u8, 83u8, 0u8, 86u8, 1u8, 26u8, + 155u8, 1u8, 32u8, 96u8, 78u8, 117u8, 108u8, 108u8, 86u8, 97u8, 108u8, 117u8, + 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 97u8, 32u8, 115u8, 105u8, 110u8, + 103u8, 108u8, 101u8, 116u8, 111u8, 110u8, 32u8, 101u8, 110u8, 117u8, 109u8, + 101u8, 114u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 116u8, 111u8, 32u8, + 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 110u8, 117u8, 108u8, 108u8, 32u8, 118u8, 97u8, 108u8, + 117u8, 101u8, 32u8, 102u8, 111u8, 114u8, 32u8, 116u8, 104u8, 101u8, 10u8, + 32u8, 96u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, 116u8, 121u8, 112u8, + 101u8, 32u8, 117u8, 110u8, 105u8, 111u8, 110u8, 46u8, 10u8, 10u8, 32u8, 84u8, + 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, + 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 102u8, 111u8, 114u8, 32u8, 96u8, 78u8, 117u8, 108u8, 108u8, 86u8, 97u8, + 108u8, 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, 78u8, + 32u8, 96u8, 110u8, 117u8, 108u8, 108u8, 96u8, 46u8, 10u8, 10u8, 10u8, 10u8, + 3u8, 5u8, 0u8, 1u8, 18u8, 3u8, 83u8, 5u8, 14u8, 10u8, 26u8, 10u8, 4u8, 5u8, + 0u8, 2u8, 0u8, 18u8, 3u8, 85u8, 2u8, 17u8, 26u8, 13u8, 32u8, 78u8, 117u8, + 108u8, 108u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, + 10u8, 5u8, 5u8, 0u8, 2u8, 0u8, 1u8, 18u8, 3u8, 85u8, 2u8, 12u8, 10u8, 12u8, + 10u8, 5u8, 5u8, 0u8, 2u8, 0u8, 2u8, 18u8, 3u8, 85u8, 15u8, 16u8, 10u8, 130u8, + 1u8, 10u8, 2u8, 4u8, 2u8, 18u8, 4u8, 91u8, 0u8, 94u8, 1u8, 26u8, 118u8, 32u8, + 96u8, 76u8, 105u8, 115u8, 116u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, + 105u8, 115u8, 32u8, 97u8, 32u8, 119u8, 114u8, 97u8, 112u8, 112u8, 101u8, + 114u8, 32u8, 97u8, 114u8, 111u8, 117u8, 110u8, 100u8, 32u8, 97u8, 32u8, + 114u8, 101u8, 112u8, 101u8, 97u8, 116u8, 101u8, 100u8, 32u8, 102u8, 105u8, + 101u8, 108u8, 100u8, 32u8, 111u8, 102u8, 32u8, 118u8, 97u8, 108u8, 117u8, + 101u8, 115u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, + 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, + 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, + 96u8, 76u8, 105u8, 115u8, 116u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, + 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 97u8, 114u8, 114u8, 97u8, + 121u8, 46u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 2u8, 1u8, 18u8, 3u8, 91u8, + 8u8, 17u8, 10u8, 58u8, 10u8, 4u8, 4u8, 2u8, 2u8, 0u8, 18u8, 3u8, 93u8, 2u8, + 28u8, 26u8, 45u8, 32u8, 82u8, 101u8, 112u8, 101u8, 97u8, 116u8, 101u8, 100u8, + 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 32u8, 111u8, 102u8, 32u8, 100u8, + 121u8, 110u8, 97u8, 109u8, 105u8, 99u8, 97u8, 108u8, 108u8, 121u8, 32u8, + 116u8, 121u8, 112u8, 101u8, 100u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 115u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 2u8, 2u8, 0u8, 4u8, 18u8, 3u8, + 93u8, 2u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 2u8, 2u8, 0u8, 6u8, 18u8, 3u8, + 93u8, 11u8, 16u8, 10u8, 12u8, 10u8, 5u8, 4u8, 2u8, 2u8, 0u8, 1u8, 18u8, 3u8, + 93u8, 17u8, 23u8, 10u8, 12u8, 10u8, 5u8, 4u8, 2u8, 2u8, 0u8, 3u8, 18u8, 3u8, + 93u8, 26u8, 27u8, 98u8, 6u8, 112u8, 114u8, 111u8, 116u8, 111u8, 51u8, 10u8, + 195u8, 49u8, 10u8, 31u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 47u8, + 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 47u8, 116u8, 105u8, + 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 46u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 18u8, 15u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, + 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 34u8, 59u8, 10u8, 9u8, + 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 18u8, 24u8, + 10u8, 7u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 24u8, 1u8, 32u8, + 1u8, 40u8, 3u8, 82u8, 7u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, + 18u8, 20u8, 10u8, 5u8, 110u8, 97u8, 110u8, 111u8, 115u8, 24u8, 2u8, 32u8, + 1u8, 40u8, 5u8, 82u8, 5u8, 110u8, 97u8, 110u8, 111u8, 115u8, 66u8, 133u8, + 1u8, 10u8, 19u8, 99u8, 111u8, 109u8, 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, + 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 66u8, + 14u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 80u8, + 114u8, 111u8, 116u8, 111u8, 80u8, 1u8, 90u8, 50u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 103u8, 111u8, 108u8, 97u8, 110u8, 103u8, 46u8, + 111u8, 114u8, 103u8, 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 47u8, 116u8, 121u8, 112u8, 101u8, 115u8, 47u8, 107u8, 110u8, 111u8, + 119u8, 110u8, 47u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, + 112u8, 112u8, 98u8, 248u8, 1u8, 1u8, 162u8, 2u8, 3u8, 71u8, 80u8, 66u8, + 170u8, 2u8, 30u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 80u8, 114u8, + 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 87u8, 101u8, 108u8, 108u8, + 75u8, 110u8, 111u8, 119u8, 110u8, 84u8, 121u8, 112u8, 101u8, 115u8, 74u8, + 193u8, 47u8, 10u8, 7u8, 18u8, 5u8, 30u8, 0u8, 143u8, 1u8, 1u8, 10u8, 204u8, + 12u8, 10u8, 1u8, 12u8, 18u8, 3u8, 30u8, 0u8, 18u8, 50u8, 193u8, 12u8, 32u8, + 80u8, 114u8, 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, 66u8, 117u8, + 102u8, 102u8, 101u8, 114u8, 115u8, 32u8, 45u8, 32u8, 71u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 39u8, 115u8, 32u8, 100u8, 97u8, 116u8, 97u8, 32u8, + 105u8, 110u8, 116u8, 101u8, 114u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, + 32u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 10u8, 32u8, 67u8, 111u8, + 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, 116u8, 32u8, 50u8, 48u8, 48u8, + 56u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 32u8, 73u8, 110u8, 99u8, + 46u8, 32u8, 32u8, 65u8, 108u8, 108u8, 32u8, 114u8, 105u8, 103u8, 104u8, + 116u8, 115u8, 32u8, 114u8, 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, + 46u8, 10u8, 32u8, 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, 100u8, + 101u8, 118u8, 101u8, 108u8, 111u8, 112u8, 101u8, 114u8, 115u8, 46u8, 103u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 99u8, 111u8, 109u8, 47u8, 112u8, + 114u8, 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 45u8, 98u8, 117u8, 102u8, + 102u8, 101u8, 114u8, 115u8, 47u8, 10u8, 10u8, 32u8, 82u8, 101u8, 100u8, + 105u8, 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 117u8, 115u8, 101u8, 32u8, 105u8, 110u8, + 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 110u8, 100u8, + 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 115u8, 44u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 111u8, 114u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 10u8, 32u8, 109u8, + 111u8, 100u8, 105u8, 102u8, 105u8, 99u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 44u8, 32u8, 97u8, 114u8, 101u8, 32u8, 112u8, 101u8, 114u8, 109u8, 105u8, + 116u8, 116u8, 101u8, 100u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, + 101u8, 100u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, + 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, + 97u8, 114u8, 101u8, 10u8, 32u8, 109u8, 101u8, 116u8, 58u8, 10u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, + 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 111u8, + 102u8, 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 99u8, 111u8, + 100u8, 101u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 116u8, + 97u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 111u8, + 118u8, 101u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, + 116u8, 10u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, 44u8, 32u8, + 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, + 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, + 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, + 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 100u8, 105u8, + 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 46u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 105u8, 110u8, + 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 112u8, 114u8, + 111u8, 100u8, 117u8, 99u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, + 98u8, 111u8, 118u8, 101u8, 10u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, + 105u8, 103u8, 104u8, 116u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, + 44u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, + 32u8, 111u8, 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, + 111u8, 110u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, + 100u8, 105u8, 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 10u8, + 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 100u8, 111u8, 99u8, + 117u8, 109u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 97u8, 110u8, 100u8, 47u8, 111u8, 114u8, 32u8, 111u8, 116u8, 104u8, 101u8, + 114u8, 32u8, 109u8, 97u8, 116u8, 101u8, 114u8, 105u8, 97u8, 108u8, 115u8, + 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 100u8, 105u8, + 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 78u8, 101u8, 105u8, 116u8, + 104u8, 101u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 110u8, 97u8, 109u8, + 101u8, 32u8, 111u8, 102u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 110u8, 111u8, 114u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, 115u8, 32u8, 111u8, 102u8, 32u8, + 105u8, 116u8, 115u8, 10u8, 32u8, 99u8, 111u8, 110u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 111u8, 114u8, 115u8, 32u8, 109u8, 97u8, 121u8, 32u8, + 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, + 101u8, 110u8, 100u8, 111u8, 114u8, 115u8, 101u8, 32u8, 111u8, 114u8, 32u8, + 112u8, 114u8, 111u8, 109u8, 111u8, 116u8, 101u8, 32u8, 112u8, 114u8, 111u8, + 100u8, 117u8, 99u8, 116u8, 115u8, 32u8, 100u8, 101u8, 114u8, 105u8, 118u8, + 101u8, 100u8, 32u8, 102u8, 114u8, 111u8, 109u8, 10u8, 32u8, 116u8, 104u8, + 105u8, 115u8, 32u8, 115u8, 111u8, 102u8, 116u8, 119u8, 97u8, 114u8, 101u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 32u8, 115u8, 112u8, + 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 112u8, 114u8, 105u8, 111u8, + 114u8, 32u8, 119u8, 114u8, 105u8, 116u8, 116u8, 101u8, 110u8, 32u8, 112u8, + 101u8, 114u8, 109u8, 105u8, 115u8, 115u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 10u8, 32u8, 84u8, 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, + 82u8, 69u8, 32u8, 73u8, 83u8, 32u8, 80u8, 82u8, 79u8, 86u8, 73u8, 68u8, 69u8, + 68u8, 32u8, 66u8, 89u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, + 82u8, 73u8, 71u8, 72u8, 84u8, 32u8, 72u8, 79u8, 76u8, 68u8, 69u8, 82u8, 83u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, + 84u8, 79u8, 82u8, 83u8, 10u8, 32u8, 34u8, 65u8, 83u8, 32u8, 73u8, 83u8, 34u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 65u8, 78u8, 89u8, 32u8, 69u8, 88u8, 80u8, 82u8, + 69u8, 83u8, 83u8, 32u8, 79u8, 82u8, 32u8, 73u8, 77u8, 80u8, 76u8, 73u8, 69u8, + 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, 73u8, 69u8, 83u8, 44u8, + 32u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, 44u8, 32u8, 66u8, + 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, 76u8, 73u8, 77u8, 73u8, 84u8, + 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 84u8, 72u8, 69u8, 32u8, 73u8, 77u8, + 80u8, 76u8, 73u8, 69u8, 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, + 73u8, 69u8, 83u8, 32u8, 79u8, 70u8, 32u8, 77u8, 69u8, 82u8, 67u8, 72u8, 65u8, + 78u8, 84u8, 65u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 65u8, 78u8, 68u8, + 32u8, 70u8, 73u8, 84u8, 78u8, 69u8, 83u8, 83u8, 32u8, 70u8, 79u8, 82u8, 10u8, + 32u8, 65u8, 32u8, 80u8, 65u8, 82u8, 84u8, 73u8, 67u8, 85u8, 76u8, 65u8, 82u8, + 32u8, 80u8, 85u8, 82u8, 80u8, 79u8, 83u8, 69u8, 32u8, 65u8, 82u8, 69u8, 32u8, + 68u8, 73u8, 83u8, 67u8, 76u8, 65u8, 73u8, 77u8, 69u8, 68u8, 46u8, 32u8, 73u8, + 78u8, 32u8, 78u8, 79u8, 32u8, 69u8, 86u8, 69u8, 78u8, 84u8, 32u8, 83u8, 72u8, + 65u8, 76u8, 76u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, 82u8, + 73u8, 71u8, 72u8, 84u8, 10u8, 32u8, 79u8, 87u8, 78u8, 69u8, 82u8, 32u8, 79u8, + 82u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, 84u8, 79u8, 82u8, + 83u8, 32u8, 66u8, 69u8, 32u8, 76u8, 73u8, 65u8, 66u8, 76u8, 69u8, 32u8, 70u8, + 79u8, 82u8, 32u8, 65u8, 78u8, 89u8, 32u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, + 44u8, 32u8, 73u8, 78u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, 44u8, 32u8, 73u8, + 78u8, 67u8, 73u8, 68u8, 69u8, 78u8, 84u8, 65u8, 76u8, 44u8, 10u8, 32u8, 83u8, + 80u8, 69u8, 67u8, 73u8, 65u8, 76u8, 44u8, 32u8, 69u8, 88u8, 69u8, 77u8, 80u8, + 76u8, 65u8, 82u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 67u8, 79u8, 78u8, 83u8, + 69u8, 81u8, 85u8, 69u8, 78u8, 84u8, 73u8, 65u8, 76u8, 32u8, 68u8, 65u8, 77u8, + 65u8, 71u8, 69u8, 83u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, + 78u8, 71u8, 44u8, 32u8, 66u8, 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, + 76u8, 73u8, 77u8, 73u8, 84u8, 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 80u8, + 82u8, 79u8, 67u8, 85u8, 82u8, 69u8, 77u8, 69u8, 78u8, 84u8, 32u8, 79u8, 70u8, + 32u8, 83u8, 85u8, 66u8, 83u8, 84u8, 73u8, 84u8, 85u8, 84u8, 69u8, 32u8, 71u8, + 79u8, 79u8, 68u8, 83u8, 32u8, 79u8, 82u8, 32u8, 83u8, 69u8, 82u8, 86u8, 73u8, + 67u8, 69u8, 83u8, 59u8, 32u8, 76u8, 79u8, 83u8, 83u8, 32u8, 79u8, 70u8, 32u8, + 85u8, 83u8, 69u8, 44u8, 10u8, 32u8, 68u8, 65u8, 84u8, 65u8, 44u8, 32u8, 79u8, + 82u8, 32u8, 80u8, 82u8, 79u8, 70u8, 73u8, 84u8, 83u8, 59u8, 32u8, 79u8, 82u8, + 32u8, 66u8, 85u8, 83u8, 73u8, 78u8, 69u8, 83u8, 83u8, 32u8, 73u8, 78u8, 84u8, + 69u8, 82u8, 82u8, 85u8, 80u8, 84u8, 73u8, 79u8, 78u8, 41u8, 32u8, 72u8, 79u8, + 87u8, 69u8, 86u8, 69u8, 82u8, 32u8, 67u8, 65u8, 85u8, 83u8, 69u8, 68u8, 32u8, + 65u8, 78u8, 68u8, 32u8, 79u8, 78u8, 32u8, 65u8, 78u8, 89u8, 10u8, 32u8, 84u8, + 72u8, 69u8, 79u8, 82u8, 89u8, 32u8, 79u8, 70u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 87u8, 72u8, 69u8, 84u8, 72u8, 69u8, + 82u8, 32u8, 73u8, 78u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 65u8, 67u8, 84u8, + 44u8, 32u8, 83u8, 84u8, 82u8, 73u8, 67u8, 84u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 84u8, 79u8, 82u8, + 84u8, 10u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, + 32u8, 78u8, 69u8, 71u8, 76u8, 73u8, 71u8, 69u8, 78u8, 67u8, 69u8, 32u8, 79u8, + 82u8, 32u8, 79u8, 84u8, 72u8, 69u8, 82u8, 87u8, 73u8, 83u8, 69u8, 41u8, 32u8, + 65u8, 82u8, 73u8, 83u8, 73u8, 78u8, 71u8, 32u8, 73u8, 78u8, 32u8, 65u8, 78u8, + 89u8, 32u8, 87u8, 65u8, 89u8, 32u8, 79u8, 85u8, 84u8, 32u8, 79u8, 70u8, 32u8, + 84u8, 72u8, 69u8, 32u8, 85u8, 83u8, 69u8, 10u8, 32u8, 79u8, 70u8, 32u8, 84u8, + 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, 82u8, 69u8, 44u8, + 32u8, 69u8, 86u8, 69u8, 78u8, 32u8, 73u8, 70u8, 32u8, 65u8, 68u8, 86u8, 73u8, + 83u8, 69u8, 68u8, 32u8, 79u8, 70u8, 32u8, 84u8, 72u8, 69u8, 32u8, 80u8, 79u8, + 83u8, 83u8, 73u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 79u8, 70u8, 32u8, + 83u8, 85u8, 67u8, 72u8, 32u8, 68u8, 65u8, 77u8, 65u8, 71u8, 69u8, 46u8, 10u8, + 10u8, 8u8, 10u8, 1u8, 2u8, 18u8, 3u8, 32u8, 0u8, 24u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 34u8, 0u8, 31u8, 10u8, 9u8, 10u8, 2u8, 8u8, 31u8, 18u8, 3u8, + 34u8, 0u8, 31u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 35u8, 0u8, 73u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 11u8, 18u8, 3u8, 35u8, 0u8, 73u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 36u8, 0u8, 44u8, 10u8, 9u8, 10u8, 2u8, 8u8, 1u8, 18u8, 3u8, + 36u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 37u8, 0u8, 47u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 8u8, 18u8, 3u8, 37u8, 0u8, 47u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 38u8, 0u8, 34u8, 10u8, 9u8, 10u8, 2u8, 8u8, 10u8, 18u8, 3u8, + 38u8, 0u8, 34u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 39u8, 0u8, 33u8, 10u8, + 9u8, 10u8, 2u8, 8u8, 36u8, 18u8, 3u8, 39u8, 0u8, 33u8, 10u8, 8u8, 10u8, 1u8, + 8u8, 18u8, 3u8, 40u8, 0u8, 59u8, 10u8, 9u8, 10u8, 2u8, 8u8, 37u8, 18u8, 3u8, + 40u8, 0u8, 59u8, 10u8, 218u8, 29u8, 10u8, 2u8, 4u8, 0u8, 18u8, 6u8, 132u8, + 1u8, 0u8, 143u8, 1u8, 1u8, 26u8, 203u8, 29u8, 32u8, 65u8, 32u8, 84u8, 105u8, + 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 114u8, 101u8, 112u8, + 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 97u8, 32u8, 112u8, + 111u8, 105u8, 110u8, 116u8, 32u8, 105u8, 110u8, 32u8, 116u8, 105u8, 109u8, + 101u8, 32u8, 105u8, 110u8, 100u8, 101u8, 112u8, 101u8, 110u8, 100u8, 101u8, + 110u8, 116u8, 32u8, 111u8, 102u8, 32u8, 97u8, 110u8, 121u8, 32u8, 116u8, + 105u8, 109u8, 101u8, 32u8, 122u8, 111u8, 110u8, 101u8, 32u8, 111u8, 114u8, + 32u8, 108u8, 111u8, 99u8, 97u8, 108u8, 10u8, 32u8, 99u8, 97u8, 108u8, 101u8, + 110u8, 100u8, 97u8, 114u8, 44u8, 32u8, 101u8, 110u8, 99u8, 111u8, 100u8, + 101u8, 100u8, 32u8, 97u8, 115u8, 32u8, 97u8, 32u8, 99u8, 111u8, 117u8, 110u8, + 116u8, 32u8, 111u8, 102u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, + 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 102u8, 114u8, 97u8, 99u8, 116u8, + 105u8, 111u8, 110u8, 115u8, 32u8, 111u8, 102u8, 32u8, 115u8, 101u8, 99u8, + 111u8, 110u8, 100u8, 115u8, 32u8, 97u8, 116u8, 10u8, 32u8, 110u8, 97u8, + 110u8, 111u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 32u8, 114u8, 101u8, + 115u8, 111u8, 108u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, 32u8, 84u8, + 104u8, 101u8, 32u8, 99u8, 111u8, 117u8, 110u8, 116u8, 32u8, 105u8, 115u8, + 32u8, 114u8, 101u8, 108u8, 97u8, 116u8, 105u8, 118u8, 101u8, 32u8, 116u8, + 111u8, 32u8, 97u8, 110u8, 32u8, 101u8, 112u8, 111u8, 99u8, 104u8, 32u8, 97u8, + 116u8, 32u8, 85u8, 84u8, 67u8, 32u8, 109u8, 105u8, 100u8, 110u8, 105u8, + 103u8, 104u8, 116u8, 32u8, 111u8, 110u8, 10u8, 32u8, 74u8, 97u8, 110u8, + 117u8, 97u8, 114u8, 121u8, 32u8, 49u8, 44u8, 32u8, 49u8, 57u8, 55u8, 48u8, + 44u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 112u8, 114u8, + 111u8, 108u8, 101u8, 112u8, 116u8, 105u8, 99u8, 32u8, 71u8, 114u8, 101u8, + 103u8, 111u8, 114u8, 105u8, 97u8, 110u8, 32u8, 99u8, 97u8, 108u8, 101u8, + 110u8, 100u8, 97u8, 114u8, 32u8, 119u8, 104u8, 105u8, 99u8, 104u8, 32u8, + 101u8, 120u8, 116u8, 101u8, 110u8, 100u8, 115u8, 32u8, 116u8, 104u8, 101u8, + 10u8, 32u8, 71u8, 114u8, 101u8, 103u8, 111u8, 114u8, 105u8, 97u8, 110u8, + 32u8, 99u8, 97u8, 108u8, 101u8, 110u8, 100u8, 97u8, 114u8, 32u8, 98u8, 97u8, + 99u8, 107u8, 119u8, 97u8, 114u8, 100u8, 115u8, 32u8, 116u8, 111u8, 32u8, + 121u8, 101u8, 97u8, 114u8, 32u8, 111u8, 110u8, 101u8, 46u8, 10u8, 10u8, 32u8, + 65u8, 108u8, 108u8, 32u8, 109u8, 105u8, 110u8, 117u8, 116u8, 101u8, 115u8, + 32u8, 97u8, 114u8, 101u8, 32u8, 54u8, 48u8, 32u8, 115u8, 101u8, 99u8, 111u8, + 110u8, 100u8, 115u8, 32u8, 108u8, 111u8, 110u8, 103u8, 46u8, 32u8, 76u8, + 101u8, 97u8, 112u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, + 32u8, 97u8, 114u8, 101u8, 32u8, 34u8, 115u8, 109u8, 101u8, 97u8, 114u8, + 101u8, 100u8, 34u8, 32u8, 115u8, 111u8, 32u8, 116u8, 104u8, 97u8, 116u8, + 32u8, 110u8, 111u8, 32u8, 108u8, 101u8, 97u8, 112u8, 10u8, 32u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 32u8, 116u8, 97u8, 98u8, 108u8, 101u8, + 32u8, 105u8, 115u8, 32u8, 110u8, 101u8, 101u8, 100u8, 101u8, 100u8, 32u8, + 102u8, 111u8, 114u8, 32u8, 105u8, 110u8, 116u8, 101u8, 114u8, 112u8, 114u8, + 101u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, 117u8, 115u8, + 105u8, 110u8, 103u8, 32u8, 97u8, 32u8, 91u8, 50u8, 52u8, 45u8, 104u8, 111u8, + 117u8, 114u8, 32u8, 108u8, 105u8, 110u8, 101u8, 97u8, 114u8, 10u8, 32u8, + 115u8, 109u8, 101u8, 97u8, 114u8, 93u8, 40u8, 104u8, 116u8, 116u8, 112u8, + 115u8, 58u8, 47u8, 47u8, 100u8, 101u8, 118u8, 101u8, 108u8, 111u8, 112u8, + 101u8, 114u8, 115u8, 46u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, + 99u8, 111u8, 109u8, 47u8, 116u8, 105u8, 109u8, 101u8, 47u8, 115u8, 109u8, + 101u8, 97u8, 114u8, 41u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, + 114u8, 97u8, 110u8, 103u8, 101u8, 32u8, 105u8, 115u8, 32u8, 102u8, 114u8, + 111u8, 109u8, 32u8, 48u8, 48u8, 48u8, 49u8, 45u8, 48u8, 49u8, 45u8, 48u8, + 49u8, 84u8, 48u8, 48u8, 58u8, 48u8, 48u8, 58u8, 48u8, 48u8, 90u8, 32u8, + 116u8, 111u8, 32u8, 57u8, 57u8, 57u8, 57u8, 45u8, 49u8, 50u8, 45u8, 51u8, + 49u8, 84u8, 50u8, 51u8, 58u8, 53u8, 57u8, 58u8, 53u8, 57u8, 46u8, 57u8, 57u8, + 57u8, 57u8, 57u8, 57u8, 57u8, 57u8, 57u8, 90u8, 46u8, 32u8, 66u8, 121u8, + 10u8, 32u8, 114u8, 101u8, 115u8, 116u8, 114u8, 105u8, 99u8, 116u8, 105u8, + 110u8, 103u8, 32u8, 116u8, 111u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, + 114u8, 97u8, 110u8, 103u8, 101u8, 44u8, 32u8, 119u8, 101u8, 32u8, 101u8, + 110u8, 115u8, 117u8, 114u8, 101u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, + 119u8, 101u8, 32u8, 99u8, 97u8, 110u8, 32u8, 99u8, 111u8, 110u8, 118u8, + 101u8, 114u8, 116u8, 32u8, 116u8, 111u8, 32u8, 97u8, 110u8, 100u8, 32u8, + 102u8, 114u8, 111u8, 109u8, 32u8, 91u8, 82u8, 70u8, 67u8, 10u8, 32u8, 51u8, + 51u8, 51u8, 57u8, 93u8, 40u8, 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, + 47u8, 119u8, 119u8, 119u8, 46u8, 105u8, 101u8, 116u8, 102u8, 46u8, 111u8, + 114u8, 103u8, 47u8, 114u8, 102u8, 99u8, 47u8, 114u8, 102u8, 99u8, 51u8, 51u8, + 51u8, 57u8, 46u8, 116u8, 120u8, 116u8, 41u8, 32u8, 100u8, 97u8, 116u8, 101u8, + 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 115u8, 46u8, 10u8, 10u8, + 32u8, 35u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 115u8, 10u8, + 10u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 49u8, 58u8, + 32u8, 67u8, 111u8, 109u8, 112u8, 117u8, 116u8, 101u8, 32u8, 84u8, 105u8, + 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 102u8, 114u8, 111u8, + 109u8, 32u8, 80u8, 79u8, 83u8, 73u8, 88u8, 32u8, 96u8, 116u8, 105u8, 109u8, + 101u8, 40u8, 41u8, 96u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 116u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 59u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, + 109u8, 112u8, 46u8, 115u8, 101u8, 116u8, 95u8, 115u8, 101u8, 99u8, 111u8, + 110u8, 100u8, 115u8, 40u8, 116u8, 105u8, 109u8, 101u8, 40u8, 78u8, 85u8, + 76u8, 76u8, 41u8, 41u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 116u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 46u8, 115u8, 101u8, + 116u8, 95u8, 110u8, 97u8, 110u8, 111u8, 115u8, 40u8, 48u8, 41u8, 59u8, 10u8, + 10u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 50u8, 58u8, + 32u8, 67u8, 111u8, 109u8, 112u8, 117u8, 116u8, 101u8, 32u8, 84u8, 105u8, + 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 102u8, 114u8, 111u8, + 109u8, 32u8, 80u8, 79u8, 83u8, 73u8, 88u8, 32u8, 96u8, 103u8, 101u8, 116u8, + 116u8, 105u8, 109u8, 101u8, 111u8, 102u8, 100u8, 97u8, 121u8, 40u8, 41u8, + 96u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 115u8, 116u8, 114u8, + 117u8, 99u8, 116u8, 32u8, 116u8, 105u8, 109u8, 101u8, 118u8, 97u8, 108u8, + 32u8, 116u8, 118u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 103u8, 101u8, + 116u8, 116u8, 105u8, 109u8, 101u8, 111u8, 102u8, 100u8, 97u8, 121u8, 40u8, + 38u8, 116u8, 118u8, 44u8, 32u8, 78u8, 85u8, 76u8, 76u8, 41u8, 59u8, 10u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, + 97u8, 109u8, 112u8, 32u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, + 109u8, 112u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 116u8, 105u8, 109u8, + 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 46u8, 115u8, 101u8, 116u8, 95u8, + 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 40u8, 116u8, 118u8, 46u8, + 116u8, 118u8, 95u8, 115u8, 101u8, 99u8, 41u8, 59u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, + 46u8, 115u8, 101u8, 116u8, 95u8, 110u8, 97u8, 110u8, 111u8, 115u8, 40u8, + 116u8, 118u8, 46u8, 116u8, 118u8, 95u8, 117u8, 115u8, 101u8, 99u8, 32u8, + 42u8, 32u8, 49u8, 48u8, 48u8, 48u8, 41u8, 59u8, 10u8, 10u8, 32u8, 69u8, + 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 51u8, 58u8, 32u8, 67u8, 111u8, + 109u8, 112u8, 117u8, 116u8, 101u8, 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, + 116u8, 97u8, 109u8, 112u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, 87u8, + 105u8, 110u8, 51u8, 50u8, 32u8, 96u8, 71u8, 101u8, 116u8, 83u8, 121u8, 115u8, + 116u8, 101u8, 109u8, 84u8, 105u8, 109u8, 101u8, 65u8, 115u8, 70u8, 105u8, + 108u8, 101u8, 84u8, 105u8, 109u8, 101u8, 40u8, 41u8, 96u8, 46u8, 10u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 70u8, 73u8, 76u8, 69u8, 84u8, 73u8, 77u8, 69u8, + 32u8, 102u8, 116u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 71u8, 101u8, + 116u8, 83u8, 121u8, 115u8, 116u8, 101u8, 109u8, 84u8, 105u8, 109u8, 101u8, + 65u8, 115u8, 70u8, 105u8, 108u8, 101u8, 84u8, 105u8, 109u8, 101u8, 40u8, + 38u8, 102u8, 116u8, 41u8, 59u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 85u8, + 73u8, 78u8, 84u8, 54u8, 52u8, 32u8, 116u8, 105u8, 99u8, 107u8, 115u8, 32u8, + 61u8, 32u8, 40u8, 40u8, 40u8, 85u8, 73u8, 78u8, 84u8, 54u8, 52u8, 41u8, + 102u8, 116u8, 46u8, 100u8, 119u8, 72u8, 105u8, 103u8, 104u8, 68u8, 97u8, + 116u8, 101u8, 84u8, 105u8, 109u8, 101u8, 41u8, 32u8, 60u8, 60u8, 32u8, 51u8, + 50u8, 41u8, 32u8, 124u8, 32u8, 102u8, 116u8, 46u8, 100u8, 119u8, 76u8, 111u8, + 119u8, 68u8, 97u8, 116u8, 101u8, 84u8, 105u8, 109u8, 101u8, 59u8, 10u8, 10u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 47u8, 47u8, 32u8, 65u8, 32u8, 87u8, 105u8, + 110u8, 100u8, 111u8, 119u8, 115u8, 32u8, 116u8, 105u8, 99u8, 107u8, 32u8, + 105u8, 115u8, 32u8, 49u8, 48u8, 48u8, 32u8, 110u8, 97u8, 110u8, 111u8, 115u8, + 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 46u8, 32u8, 87u8, 105u8, 110u8, + 100u8, 111u8, 119u8, 115u8, 32u8, 101u8, 112u8, 111u8, 99u8, 104u8, 32u8, + 49u8, 54u8, 48u8, 49u8, 45u8, 48u8, 49u8, 45u8, 48u8, 49u8, 84u8, 48u8, 48u8, + 58u8, 48u8, 48u8, 58u8, 48u8, 48u8, 90u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 47u8, 47u8, 32u8, 105u8, 115u8, 32u8, 49u8, 49u8, 54u8, 52u8, 52u8, 52u8, + 55u8, 51u8, 54u8, 48u8, 48u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, + 115u8, 32u8, 98u8, 101u8, 102u8, 111u8, 114u8, 101u8, 32u8, 85u8, 110u8, + 105u8, 120u8, 32u8, 101u8, 112u8, 111u8, 99u8, 104u8, 32u8, 49u8, 57u8, 55u8, + 48u8, 45u8, 48u8, 49u8, 45u8, 48u8, 49u8, 84u8, 48u8, 48u8, 58u8, 48u8, 48u8, + 58u8, 48u8, 48u8, 90u8, 46u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 84u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 116u8, 105u8, + 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 59u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, + 46u8, 115u8, 101u8, 116u8, 95u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, + 115u8, 40u8, 40u8, 73u8, 78u8, 84u8, 54u8, 52u8, 41u8, 32u8, 40u8, 40u8, + 116u8, 105u8, 99u8, 107u8, 115u8, 32u8, 47u8, 32u8, 49u8, 48u8, 48u8, 48u8, + 48u8, 48u8, 48u8, 48u8, 41u8, 32u8, 45u8, 32u8, 49u8, 49u8, 54u8, 52u8, 52u8, + 52u8, 55u8, 51u8, 54u8, 48u8, 48u8, 76u8, 76u8, 41u8, 41u8, 59u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, + 109u8, 112u8, 46u8, 115u8, 101u8, 116u8, 95u8, 110u8, 97u8, 110u8, 111u8, + 115u8, 40u8, 40u8, 73u8, 78u8, 84u8, 51u8, 50u8, 41u8, 32u8, 40u8, 40u8, + 116u8, 105u8, 99u8, 107u8, 115u8, 32u8, 37u8, 32u8, 49u8, 48u8, 48u8, 48u8, + 48u8, 48u8, 48u8, 48u8, 41u8, 32u8, 42u8, 32u8, 49u8, 48u8, 48u8, 41u8, 41u8, + 59u8, 10u8, 10u8, 32u8, 69u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, + 52u8, 58u8, 32u8, 67u8, 111u8, 109u8, 112u8, 117u8, 116u8, 101u8, 32u8, 84u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 102u8, 114u8, + 111u8, 109u8, 32u8, 74u8, 97u8, 118u8, 97u8, 32u8, 96u8, 83u8, 121u8, 115u8, + 116u8, 101u8, 109u8, 46u8, 99u8, 117u8, 114u8, 114u8, 101u8, 110u8, 116u8, + 84u8, 105u8, 109u8, 101u8, 77u8, 105u8, 108u8, 108u8, 105u8, 115u8, 40u8, + 41u8, 96u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 108u8, 111u8, + 110u8, 103u8, 32u8, 109u8, 105u8, 108u8, 108u8, 105u8, 115u8, 32u8, 61u8, + 32u8, 83u8, 121u8, 115u8, 116u8, 101u8, 109u8, 46u8, 99u8, 117u8, 114u8, + 114u8, 101u8, 110u8, 116u8, 84u8, 105u8, 109u8, 101u8, 77u8, 105u8, 108u8, + 108u8, 105u8, 115u8, 40u8, 41u8, 59u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, + 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 61u8, + 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 46u8, + 110u8, 101u8, 119u8, 66u8, 117u8, 105u8, 108u8, 100u8, 101u8, 114u8, 40u8, + 41u8, 46u8, 115u8, 101u8, 116u8, 83u8, 101u8, 99u8, 111u8, 110u8, 100u8, + 115u8, 40u8, 109u8, 105u8, 108u8, 108u8, 105u8, 115u8, 32u8, 47u8, 32u8, + 49u8, 48u8, 48u8, 48u8, 41u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 46u8, 115u8, 101u8, 116u8, 78u8, 97u8, 110u8, 111u8, 115u8, 40u8, + 40u8, 105u8, 110u8, 116u8, 41u8, 32u8, 40u8, 40u8, 109u8, 105u8, 108u8, + 108u8, 105u8, 115u8, 32u8, 37u8, 32u8, 49u8, 48u8, 48u8, 48u8, 41u8, 32u8, + 42u8, 32u8, 49u8, 48u8, 48u8, 48u8, 48u8, 48u8, 48u8, 41u8, 41u8, 46u8, 98u8, + 117u8, 105u8, 108u8, 100u8, 40u8, 41u8, 59u8, 10u8, 10u8, 32u8, 69u8, 120u8, + 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 53u8, 58u8, 32u8, 67u8, 111u8, 109u8, + 112u8, 117u8, 116u8, 101u8, 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, + 97u8, 109u8, 112u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, 74u8, 97u8, + 118u8, 97u8, 32u8, 96u8, 73u8, 110u8, 115u8, 116u8, 97u8, 110u8, 116u8, 46u8, + 110u8, 111u8, 119u8, 40u8, 41u8, 96u8, 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 73u8, 110u8, 115u8, 116u8, 97u8, 110u8, 116u8, 32u8, 110u8, + 111u8, 119u8, 32u8, 61u8, 32u8, 73u8, 110u8, 115u8, 116u8, 97u8, 110u8, + 116u8, 46u8, 110u8, 111u8, 119u8, 40u8, 41u8, 59u8, 10u8, 10u8, 32u8, 32u8, + 32u8, 32u8, 32u8, 84u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, + 112u8, 32u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, + 32u8, 61u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 84u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 46u8, 110u8, 101u8, + 119u8, 66u8, 117u8, 105u8, 108u8, 100u8, 101u8, 114u8, 40u8, 41u8, 46u8, + 115u8, 101u8, 116u8, 83u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 40u8, + 110u8, 111u8, 119u8, 46u8, 103u8, 101u8, 116u8, 69u8, 112u8, 111u8, 99u8, + 104u8, 83u8, 101u8, 99u8, 111u8, 110u8, 100u8, 40u8, 41u8, 41u8, 10u8, 32u8, + 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 32u8, 46u8, + 115u8, 101u8, 116u8, 78u8, 97u8, 110u8, 111u8, 115u8, 40u8, 110u8, 111u8, + 119u8, 46u8, 103u8, 101u8, 116u8, 78u8, 97u8, 110u8, 111u8, 40u8, 41u8, 41u8, + 46u8, 98u8, 117u8, 105u8, 108u8, 100u8, 40u8, 41u8, 59u8, 10u8, 10u8, 32u8, + 69u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 32u8, 54u8, 58u8, 32u8, 67u8, + 111u8, 109u8, 112u8, 117u8, 116u8, 101u8, 32u8, 84u8, 105u8, 109u8, 101u8, + 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, + 99u8, 117u8, 114u8, 114u8, 101u8, 110u8, 116u8, 32u8, 116u8, 105u8, 109u8, + 101u8, 32u8, 105u8, 110u8, 32u8, 80u8, 121u8, 116u8, 104u8, 111u8, 110u8, + 46u8, 10u8, 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 116u8, 105u8, 109u8, 101u8, + 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 61u8, 32u8, 84u8, 105u8, 109u8, + 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 40u8, 41u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 116u8, 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, + 46u8, 71u8, 101u8, 116u8, 67u8, 117u8, 114u8, 114u8, 101u8, 110u8, 116u8, + 84u8, 105u8, 109u8, 101u8, 40u8, 41u8, 10u8, 10u8, 32u8, 35u8, 32u8, 74u8, + 83u8, 79u8, 78u8, 32u8, 77u8, 97u8, 112u8, 112u8, 105u8, 110u8, 103u8, 10u8, + 10u8, 32u8, 73u8, 110u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 102u8, 111u8, + 114u8, 109u8, 97u8, 116u8, 44u8, 32u8, 116u8, 104u8, 101u8, 32u8, 84u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 116u8, 121u8, + 112u8, 101u8, 32u8, 105u8, 115u8, 32u8, 101u8, 110u8, 99u8, 111u8, 100u8, + 101u8, 100u8, 32u8, 97u8, 115u8, 32u8, 97u8, 32u8, 115u8, 116u8, 114u8, + 105u8, 110u8, 103u8, 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 10u8, + 32u8, 91u8, 82u8, 70u8, 67u8, 32u8, 51u8, 51u8, 51u8, 57u8, 93u8, 40u8, + 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, 119u8, 119u8, 119u8, + 46u8, 105u8, 101u8, 116u8, 102u8, 46u8, 111u8, 114u8, 103u8, 47u8, 114u8, + 102u8, 99u8, 47u8, 114u8, 102u8, 99u8, 51u8, 51u8, 51u8, 57u8, 46u8, 116u8, + 120u8, 116u8, 41u8, 32u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 46u8, + 32u8, 84u8, 104u8, 97u8, 116u8, 32u8, 105u8, 115u8, 44u8, 32u8, 116u8, 104u8, + 101u8, 10u8, 32u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 32u8, 105u8, + 115u8, 32u8, 34u8, 123u8, 121u8, 101u8, 97u8, 114u8, 125u8, 45u8, 123u8, + 109u8, 111u8, 110u8, 116u8, 104u8, 125u8, 45u8, 123u8, 100u8, 97u8, 121u8, + 125u8, 84u8, 123u8, 104u8, 111u8, 117u8, 114u8, 125u8, 58u8, 123u8, 109u8, + 105u8, 110u8, 125u8, 58u8, 123u8, 115u8, 101u8, 99u8, 125u8, 91u8, 46u8, + 123u8, 102u8, 114u8, 97u8, 99u8, 95u8, 115u8, 101u8, 99u8, 125u8, 93u8, 90u8, + 34u8, 10u8, 32u8, 119u8, 104u8, 101u8, 114u8, 101u8, 32u8, 123u8, 121u8, + 101u8, 97u8, 114u8, 125u8, 32u8, 105u8, 115u8, 32u8, 97u8, 108u8, 119u8, + 97u8, 121u8, 115u8, 32u8, 101u8, 120u8, 112u8, 114u8, 101u8, 115u8, 115u8, + 101u8, 100u8, 32u8, 117u8, 115u8, 105u8, 110u8, 103u8, 32u8, 102u8, 111u8, + 117u8, 114u8, 32u8, 100u8, 105u8, 103u8, 105u8, 116u8, 115u8, 32u8, 119u8, + 104u8, 105u8, 108u8, 101u8, 32u8, 123u8, 109u8, 111u8, 110u8, 116u8, 104u8, + 125u8, 44u8, 32u8, 123u8, 100u8, 97u8, 121u8, 125u8, 44u8, 10u8, 32u8, 123u8, + 104u8, 111u8, 117u8, 114u8, 125u8, 44u8, 32u8, 123u8, 109u8, 105u8, 110u8, + 125u8, 44u8, 32u8, 97u8, 110u8, 100u8, 32u8, 123u8, 115u8, 101u8, 99u8, + 125u8, 32u8, 97u8, 114u8, 101u8, 32u8, 122u8, 101u8, 114u8, 111u8, 45u8, + 112u8, 97u8, 100u8, 100u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, 116u8, + 119u8, 111u8, 32u8, 100u8, 105u8, 103u8, 105u8, 116u8, 115u8, 32u8, 101u8, + 97u8, 99u8, 104u8, 46u8, 32u8, 84u8, 104u8, 101u8, 32u8, 102u8, 114u8, 97u8, + 99u8, 116u8, 105u8, 111u8, 110u8, 97u8, 108u8, 10u8, 32u8, 115u8, 101u8, + 99u8, 111u8, 110u8, 100u8, 115u8, 44u8, 32u8, 119u8, 104u8, 105u8, 99u8, + 104u8, 32u8, 99u8, 97u8, 110u8, 32u8, 103u8, 111u8, 32u8, 117u8, 112u8, 32u8, + 116u8, 111u8, 32u8, 57u8, 32u8, 100u8, 105u8, 103u8, 105u8, 116u8, 115u8, + 32u8, 40u8, 105u8, 46u8, 101u8, 46u8, 32u8, 117u8, 112u8, 32u8, 116u8, 111u8, + 32u8, 49u8, 32u8, 110u8, 97u8, 110u8, 111u8, 115u8, 101u8, 99u8, 111u8, + 110u8, 100u8, 32u8, 114u8, 101u8, 115u8, 111u8, 108u8, 117u8, 116u8, 105u8, + 111u8, 110u8, 41u8, 44u8, 10u8, 32u8, 97u8, 114u8, 101u8, 32u8, 111u8, 112u8, + 116u8, 105u8, 111u8, 110u8, 97u8, 108u8, 46u8, 32u8, 84u8, 104u8, 101u8, + 32u8, 34u8, 90u8, 34u8, 32u8, 115u8, 117u8, 102u8, 102u8, 105u8, 120u8, 32u8, + 105u8, 110u8, 100u8, 105u8, 99u8, 97u8, 116u8, 101u8, 115u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 116u8, 105u8, 109u8, 101u8, 122u8, 111u8, 110u8, 101u8, + 32u8, 40u8, 34u8, 85u8, 84u8, 67u8, 34u8, 41u8, 59u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 116u8, 105u8, 109u8, 101u8, 122u8, 111u8, 110u8, 101u8, 10u8, + 32u8, 105u8, 115u8, 32u8, 114u8, 101u8, 113u8, 117u8, 105u8, 114u8, 101u8, + 100u8, 46u8, 32u8, 65u8, 32u8, 112u8, 114u8, 111u8, 116u8, 111u8, 51u8, 32u8, + 74u8, 83u8, 79u8, 78u8, 32u8, 115u8, 101u8, 114u8, 105u8, 97u8, 108u8, 105u8, + 122u8, 101u8, 114u8, 32u8, 115u8, 104u8, 111u8, 117u8, 108u8, 100u8, 32u8, + 97u8, 108u8, 119u8, 97u8, 121u8, 115u8, 32u8, 117u8, 115u8, 101u8, 32u8, + 85u8, 84u8, 67u8, 32u8, 40u8, 97u8, 115u8, 32u8, 105u8, 110u8, 100u8, 105u8, + 99u8, 97u8, 116u8, 101u8, 100u8, 32u8, 98u8, 121u8, 10u8, 32u8, 34u8, 90u8, + 34u8, 41u8, 32u8, 119u8, 104u8, 101u8, 110u8, 32u8, 112u8, 114u8, 105u8, + 110u8, 116u8, 105u8, 110u8, 103u8, 32u8, 116u8, 104u8, 101u8, 32u8, 84u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 32u8, 116u8, 121u8, + 112u8, 101u8, 32u8, 97u8, 110u8, 100u8, 32u8, 97u8, 32u8, 112u8, 114u8, + 111u8, 116u8, 111u8, 51u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 112u8, 97u8, + 114u8, 115u8, 101u8, 114u8, 32u8, 115u8, 104u8, 111u8, 117u8, 108u8, 100u8, + 32u8, 98u8, 101u8, 10u8, 32u8, 97u8, 98u8, 108u8, 101u8, 32u8, 116u8, 111u8, + 32u8, 97u8, 99u8, 99u8, 101u8, 112u8, 116u8, 32u8, 98u8, 111u8, 116u8, 104u8, + 32u8, 85u8, 84u8, 67u8, 32u8, 97u8, 110u8, 100u8, 32u8, 111u8, 116u8, 104u8, + 101u8, 114u8, 32u8, 116u8, 105u8, 109u8, 101u8, 122u8, 111u8, 110u8, 101u8, + 115u8, 32u8, 40u8, 97u8, 115u8, 32u8, 105u8, 110u8, 100u8, 105u8, 99u8, 97u8, + 116u8, 101u8, 100u8, 32u8, 98u8, 121u8, 32u8, 97u8, 110u8, 32u8, 111u8, + 102u8, 102u8, 115u8, 101u8, 116u8, 41u8, 46u8, 10u8, 10u8, 32u8, 70u8, 111u8, + 114u8, 32u8, 101u8, 120u8, 97u8, 109u8, 112u8, 108u8, 101u8, 44u8, 32u8, + 34u8, 50u8, 48u8, 49u8, 55u8, 45u8, 48u8, 49u8, 45u8, 49u8, 53u8, 84u8, 48u8, + 49u8, 58u8, 51u8, 48u8, 58u8, 49u8, 53u8, 46u8, 48u8, 49u8, 90u8, 34u8, 32u8, + 101u8, 110u8, 99u8, 111u8, 100u8, 101u8, 115u8, 32u8, 49u8, 53u8, 46u8, 48u8, + 49u8, 32u8, 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 115u8, 32u8, 112u8, + 97u8, 115u8, 116u8, 10u8, 32u8, 48u8, 49u8, 58u8, 51u8, 48u8, 32u8, 85u8, + 84u8, 67u8, 32u8, 111u8, 110u8, 32u8, 74u8, 97u8, 110u8, 117u8, 97u8, 114u8, + 121u8, 32u8, 49u8, 53u8, 44u8, 32u8, 50u8, 48u8, 49u8, 55u8, 46u8, 10u8, + 10u8, 32u8, 73u8, 110u8, 32u8, 74u8, 97u8, 118u8, 97u8, 83u8, 99u8, 114u8, + 105u8, 112u8, 116u8, 44u8, 32u8, 111u8, 110u8, 101u8, 32u8, 99u8, 97u8, + 110u8, 32u8, 99u8, 111u8, 110u8, 118u8, 101u8, 114u8, 116u8, 32u8, 97u8, + 32u8, 68u8, 97u8, 116u8, 101u8, 32u8, 111u8, 98u8, 106u8, 101u8, 99u8, 116u8, + 32u8, 116u8, 111u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 102u8, 111u8, + 114u8, 109u8, 97u8, 116u8, 32u8, 117u8, 115u8, 105u8, 110u8, 103u8, 32u8, + 116u8, 104u8, 101u8, 10u8, 32u8, 115u8, 116u8, 97u8, 110u8, 100u8, 97u8, + 114u8, 100u8, 10u8, 32u8, 91u8, 116u8, 111u8, 73u8, 83u8, 79u8, 83u8, 116u8, + 114u8, 105u8, 110u8, 103u8, 40u8, 41u8, 93u8, 40u8, 104u8, 116u8, 116u8, + 112u8, 115u8, 58u8, 47u8, 47u8, 100u8, 101u8, 118u8, 101u8, 108u8, 111u8, + 112u8, 101u8, 114u8, 46u8, 109u8, 111u8, 122u8, 105u8, 108u8, 108u8, 97u8, + 46u8, 111u8, 114u8, 103u8, 47u8, 101u8, 110u8, 45u8, 85u8, 83u8, 47u8, 100u8, + 111u8, 99u8, 115u8, 47u8, 87u8, 101u8, 98u8, 47u8, 74u8, 97u8, 118u8, 97u8, + 83u8, 99u8, 114u8, 105u8, 112u8, 116u8, 47u8, 82u8, 101u8, 102u8, 101u8, + 114u8, 101u8, 110u8, 99u8, 101u8, 47u8, 71u8, 108u8, 111u8, 98u8, 97u8, + 108u8, 95u8, 79u8, 98u8, 106u8, 101u8, 99u8, 116u8, 115u8, 47u8, 68u8, 97u8, + 116u8, 101u8, 47u8, 116u8, 111u8, 73u8, 83u8, 79u8, 83u8, 116u8, 114u8, + 105u8, 110u8, 103u8, 41u8, 10u8, 32u8, 109u8, 101u8, 116u8, 104u8, 111u8, + 100u8, 46u8, 32u8, 73u8, 110u8, 32u8, 80u8, 121u8, 116u8, 104u8, 111u8, + 110u8, 44u8, 32u8, 97u8, 32u8, 115u8, 116u8, 97u8, 110u8, 100u8, 97u8, 114u8, + 100u8, 32u8, 96u8, 100u8, 97u8, 116u8, 101u8, 116u8, 105u8, 109u8, 101u8, + 46u8, 100u8, 97u8, 116u8, 101u8, 116u8, 105u8, 109u8, 101u8, 96u8, 32u8, + 111u8, 98u8, 106u8, 101u8, 99u8, 116u8, 32u8, 99u8, 97u8, 110u8, 32u8, 98u8, + 101u8, 32u8, 99u8, 111u8, 110u8, 118u8, 101u8, 114u8, 116u8, 101u8, 100u8, + 10u8, 32u8, 116u8, 111u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 102u8, + 111u8, 114u8, 109u8, 97u8, 116u8, 32u8, 117u8, 115u8, 105u8, 110u8, 103u8, + 10u8, 32u8, 91u8, 96u8, 115u8, 116u8, 114u8, 102u8, 116u8, 105u8, 109u8, + 101u8, 96u8, 93u8, 40u8, 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, + 100u8, 111u8, 99u8, 115u8, 46u8, 112u8, 121u8, 116u8, 104u8, 111u8, 110u8, + 46u8, 111u8, 114u8, 103u8, 47u8, 50u8, 47u8, 108u8, 105u8, 98u8, 114u8, 97u8, + 114u8, 121u8, 47u8, 116u8, 105u8, 109u8, 101u8, 46u8, 104u8, 116u8, 109u8, + 108u8, 35u8, 116u8, 105u8, 109u8, 101u8, 46u8, 115u8, 116u8, 114u8, 102u8, + 116u8, 105u8, 109u8, 101u8, 41u8, 32u8, 119u8, 105u8, 116u8, 104u8, 10u8, + 32u8, 116u8, 104u8, 101u8, 32u8, 116u8, 105u8, 109u8, 101u8, 32u8, 102u8, + 111u8, 114u8, 109u8, 97u8, 116u8, 32u8, 115u8, 112u8, 101u8, 99u8, 32u8, + 39u8, 37u8, 89u8, 45u8, 37u8, 109u8, 45u8, 37u8, 100u8, 84u8, 37u8, 72u8, + 58u8, 37u8, 77u8, 58u8, 37u8, 83u8, 46u8, 37u8, 102u8, 90u8, 39u8, 46u8, + 32u8, 76u8, 105u8, 107u8, 101u8, 119u8, 105u8, 115u8, 101u8, 44u8, 32u8, + 105u8, 110u8, 32u8, 74u8, 97u8, 118u8, 97u8, 44u8, 32u8, 111u8, 110u8, 101u8, + 32u8, 99u8, 97u8, 110u8, 32u8, 117u8, 115u8, 101u8, 10u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 74u8, 111u8, 100u8, 97u8, 32u8, 84u8, 105u8, 109u8, 101u8, 39u8, + 115u8, 32u8, 91u8, 96u8, 73u8, 83u8, 79u8, 68u8, 97u8, 116u8, 101u8, 84u8, + 105u8, 109u8, 101u8, 70u8, 111u8, 114u8, 109u8, 97u8, 116u8, 46u8, 100u8, + 97u8, 116u8, 101u8, 84u8, 105u8, 109u8, 101u8, 40u8, 41u8, 96u8, 93u8, 40u8, + 10u8, 32u8, 104u8, 116u8, 116u8, 112u8, 58u8, 47u8, 47u8, 106u8, 111u8, + 100u8, 97u8, 45u8, 116u8, 105u8, 109u8, 101u8, 46u8, 115u8, 111u8, 117u8, + 114u8, 99u8, 101u8, 102u8, 111u8, 114u8, 103u8, 101u8, 46u8, 110u8, 101u8, + 116u8, 47u8, 97u8, 112u8, 105u8, 100u8, 111u8, 99u8, 115u8, 47u8, 111u8, + 114u8, 103u8, 47u8, 106u8, 111u8, 100u8, 97u8, 47u8, 116u8, 105u8, 109u8, + 101u8, 47u8, 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 47u8, 73u8, 83u8, 79u8, + 68u8, 97u8, 116u8, 101u8, 84u8, 105u8, 109u8, 101u8, 70u8, 111u8, 114u8, + 109u8, 97u8, 116u8, 46u8, 104u8, 116u8, 109u8, 108u8, 35u8, 100u8, 97u8, + 116u8, 101u8, 84u8, 105u8, 109u8, 101u8, 40u8, 41u8, 10u8, 32u8, 41u8, 32u8, + 116u8, 111u8, 32u8, 111u8, 98u8, 116u8, 97u8, 105u8, 110u8, 32u8, 97u8, 32u8, + 102u8, 111u8, 114u8, 109u8, 97u8, 116u8, 116u8, 101u8, 114u8, 32u8, 99u8, + 97u8, 112u8, 97u8, 98u8, 108u8, 101u8, 32u8, 111u8, 102u8, 32u8, 103u8, + 101u8, 110u8, 101u8, 114u8, 97u8, 116u8, 105u8, 110u8, 103u8, 32u8, 116u8, + 105u8, 109u8, 101u8, 115u8, 116u8, 97u8, 109u8, 112u8, 115u8, 32u8, 105u8, + 110u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 102u8, 111u8, 114u8, 109u8, + 97u8, 116u8, 46u8, 10u8, 10u8, 10u8, 11u8, 10u8, 3u8, 4u8, 0u8, 1u8, 18u8, + 4u8, 132u8, 1u8, 8u8, 17u8, 10u8, 157u8, 1u8, 10u8, 4u8, 4u8, 0u8, 2u8, 0u8, + 18u8, 4u8, 136u8, 1u8, 2u8, 20u8, 26u8, 142u8, 1u8, 32u8, 82u8, 101u8, 112u8, + 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 115u8, 32u8, 115u8, 101u8, 99u8, + 111u8, 110u8, 100u8, 115u8, 32u8, 111u8, 102u8, 32u8, 85u8, 84u8, 67u8, 32u8, + 116u8, 105u8, 109u8, 101u8, 32u8, 115u8, 105u8, 110u8, 99u8, 101u8, 32u8, + 85u8, 110u8, 105u8, 120u8, 32u8, 101u8, 112u8, 111u8, 99u8, 104u8, 10u8, + 32u8, 49u8, 57u8, 55u8, 48u8, 45u8, 48u8, 49u8, 45u8, 48u8, 49u8, 84u8, 48u8, + 48u8, 58u8, 48u8, 48u8, 58u8, 48u8, 48u8, 90u8, 46u8, 32u8, 77u8, 117u8, + 115u8, 116u8, 32u8, 98u8, 101u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, + 48u8, 48u8, 48u8, 49u8, 45u8, 48u8, 49u8, 45u8, 48u8, 49u8, 84u8, 48u8, 48u8, + 58u8, 48u8, 48u8, 58u8, 48u8, 48u8, 90u8, 32u8, 116u8, 111u8, 10u8, 32u8, + 57u8, 57u8, 57u8, 57u8, 45u8, 49u8, 50u8, 45u8, 51u8, 49u8, 84u8, 50u8, 51u8, + 58u8, 53u8, 57u8, 58u8, 53u8, 57u8, 90u8, 32u8, 105u8, 110u8, 99u8, 108u8, + 117u8, 115u8, 105u8, 118u8, 101u8, 46u8, 10u8, 10u8, 13u8, 10u8, 5u8, 4u8, + 0u8, 2u8, 0u8, 5u8, 18u8, 4u8, 136u8, 1u8, 2u8, 7u8, 10u8, 13u8, 10u8, 5u8, + 4u8, 0u8, 2u8, 0u8, 1u8, 18u8, 4u8, 136u8, 1u8, 8u8, 15u8, 10u8, 13u8, 10u8, + 5u8, 4u8, 0u8, 2u8, 0u8, 3u8, 18u8, 4u8, 136u8, 1u8, 18u8, 19u8, 10u8, 229u8, + 1u8, 10u8, 4u8, 4u8, 0u8, 2u8, 1u8, 18u8, 4u8, 142u8, 1u8, 2u8, 18u8, 26u8, + 214u8, 1u8, 32u8, 78u8, 111u8, 110u8, 45u8, 110u8, 101u8, 103u8, 97u8, 116u8, + 105u8, 118u8, 101u8, 32u8, 102u8, 114u8, 97u8, 99u8, 116u8, 105u8, 111u8, + 110u8, 115u8, 32u8, 111u8, 102u8, 32u8, 97u8, 32u8, 115u8, 101u8, 99u8, + 111u8, 110u8, 100u8, 32u8, 97u8, 116u8, 32u8, 110u8, 97u8, 110u8, 111u8, + 115u8, 101u8, 99u8, 111u8, 110u8, 100u8, 32u8, 114u8, 101u8, 115u8, 111u8, + 108u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, 32u8, 78u8, 101u8, 103u8, + 97u8, 116u8, 105u8, 118u8, 101u8, 10u8, 32u8, 115u8, 101u8, 99u8, 111u8, + 110u8, 100u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 102u8, 114u8, 97u8, 99u8, 116u8, 105u8, 111u8, + 110u8, 115u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 115u8, 116u8, 105u8, + 108u8, 108u8, 32u8, 104u8, 97u8, 118u8, 101u8, 32u8, 110u8, 111u8, 110u8, + 45u8, 110u8, 101u8, 103u8, 97u8, 116u8, 105u8, 118u8, 101u8, 32u8, 110u8, + 97u8, 110u8, 111u8, 115u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 115u8, + 10u8, 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 99u8, 111u8, 117u8, 110u8, + 116u8, 32u8, 102u8, 111u8, 114u8, 119u8, 97u8, 114u8, 100u8, 32u8, 105u8, + 110u8, 32u8, 116u8, 105u8, 109u8, 101u8, 46u8, 32u8, 77u8, 117u8, 115u8, + 116u8, 32u8, 98u8, 101u8, 32u8, 102u8, 114u8, 111u8, 109u8, 32u8, 48u8, 32u8, + 116u8, 111u8, 32u8, 57u8, 57u8, 57u8, 44u8, 57u8, 57u8, 57u8, 44u8, 57u8, + 57u8, 57u8, 10u8, 32u8, 105u8, 110u8, 99u8, 108u8, 117u8, 115u8, 105u8, + 118u8, 101u8, 46u8, 10u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, 1u8, 5u8, + 18u8, 4u8, 142u8, 1u8, 2u8, 7u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, 1u8, + 1u8, 18u8, 4u8, 142u8, 1u8, 8u8, 13u8, 10u8, 13u8, 10u8, 5u8, 4u8, 0u8, 2u8, + 1u8, 3u8, 18u8, 4u8, 142u8, 1u8, 16u8, 17u8, 98u8, 6u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 51u8, 10u8, 205u8, 35u8, 10u8, 30u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 47u8, 119u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 115u8, 46u8, + 112u8, 114u8, 111u8, 116u8, 111u8, 18u8, 15u8, 103u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, + 34u8, 35u8, 10u8, 11u8, 68u8, 111u8, 117u8, 98u8, 108u8, 101u8, 86u8, 97u8, + 108u8, 117u8, 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 24u8, 1u8, 32u8, 1u8, 40u8, 1u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 34u8, 34u8, 10u8, 10u8, 70u8, 108u8, 111u8, 97u8, 116u8, 86u8, 97u8, 108u8, + 117u8, 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, + 1u8, 32u8, 1u8, 40u8, 2u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 34u8, + 34u8, 10u8, 10u8, 73u8, 110u8, 116u8, 54u8, 52u8, 86u8, 97u8, 108u8, 117u8, + 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, 1u8, + 32u8, 1u8, 40u8, 3u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 34u8, + 35u8, 10u8, 11u8, 85u8, 73u8, 110u8, 116u8, 54u8, 52u8, 86u8, 97u8, 108u8, + 117u8, 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, + 1u8, 32u8, 1u8, 40u8, 4u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 34u8, + 34u8, 10u8, 10u8, 73u8, 110u8, 116u8, 51u8, 50u8, 86u8, 97u8, 108u8, 117u8, + 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, 1u8, + 32u8, 1u8, 40u8, 5u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 34u8, + 35u8, 10u8, 11u8, 85u8, 73u8, 110u8, 116u8, 51u8, 50u8, 86u8, 97u8, 108u8, + 117u8, 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, + 1u8, 32u8, 1u8, 40u8, 13u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 34u8, 33u8, 10u8, 9u8, 66u8, 111u8, 111u8, 108u8, 86u8, 97u8, 108u8, 117u8, + 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, 1u8, + 32u8, 1u8, 40u8, 8u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 34u8, + 35u8, 10u8, 11u8, 83u8, 116u8, 114u8, 105u8, 110u8, 103u8, 86u8, 97u8, 108u8, + 117u8, 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, + 1u8, 32u8, 1u8, 40u8, 9u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 34u8, + 34u8, 10u8, 10u8, 66u8, 121u8, 116u8, 101u8, 115u8, 86u8, 97u8, 108u8, 117u8, + 101u8, 18u8, 20u8, 10u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 24u8, 1u8, + 32u8, 1u8, 40u8, 12u8, 82u8, 5u8, 118u8, 97u8, 108u8, 117u8, 101u8, 66u8, + 131u8, 1u8, 10u8, 19u8, 99u8, 111u8, 109u8, 46u8, 103u8, 111u8, 111u8, 103u8, + 108u8, 101u8, 46u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, + 66u8, 13u8, 87u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 115u8, 80u8, + 114u8, 111u8, 116u8, 111u8, 80u8, 1u8, 90u8, 49u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 103u8, 111u8, 108u8, 97u8, 110u8, 103u8, 46u8, + 111u8, 114u8, 103u8, 47u8, 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, + 102u8, 47u8, 116u8, 121u8, 112u8, 101u8, 115u8, 47u8, 107u8, 110u8, 111u8, + 119u8, 110u8, 47u8, 119u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 115u8, + 112u8, 98u8, 248u8, 1u8, 1u8, 162u8, 2u8, 3u8, 71u8, 80u8, 66u8, 170u8, 2u8, + 30u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, 80u8, 114u8, 111u8, + 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 87u8, 101u8, 108u8, 108u8, 75u8, + 110u8, 111u8, 119u8, 110u8, 84u8, 121u8, 112u8, 101u8, 115u8, 74u8, 196u8, + 31u8, 10u8, 6u8, 18u8, 4u8, 40u8, 0u8, 122u8, 1u8, 10u8, 217u8, 16u8, 10u8, + 1u8, 12u8, 18u8, 3u8, 40u8, 0u8, 18u8, 50u8, 206u8, 16u8, 32u8, 80u8, 114u8, + 111u8, 116u8, 111u8, 99u8, 111u8, 108u8, 32u8, 66u8, 117u8, 102u8, 102u8, + 101u8, 114u8, 115u8, 32u8, 45u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, + 101u8, 39u8, 115u8, 32u8, 100u8, 97u8, 116u8, 97u8, 32u8, 105u8, 110u8, + 116u8, 101u8, 114u8, 99u8, 104u8, 97u8, 110u8, 103u8, 101u8, 32u8, 102u8, + 111u8, 114u8, 109u8, 97u8, 116u8, 10u8, 32u8, 67u8, 111u8, 112u8, 121u8, + 114u8, 105u8, 103u8, 104u8, 116u8, 32u8, 50u8, 48u8, 48u8, 56u8, 32u8, 71u8, + 111u8, 111u8, 103u8, 108u8, 101u8, 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 32u8, + 65u8, 108u8, 108u8, 32u8, 114u8, 105u8, 103u8, 104u8, 116u8, 115u8, 32u8, + 114u8, 101u8, 115u8, 101u8, 114u8, 118u8, 101u8, 100u8, 46u8, 10u8, 32u8, + 104u8, 116u8, 116u8, 112u8, 115u8, 58u8, 47u8, 47u8, 100u8, 101u8, 118u8, + 101u8, 108u8, 111u8, 112u8, 101u8, 114u8, 115u8, 46u8, 103u8, 111u8, 111u8, + 103u8, 108u8, 101u8, 46u8, 99u8, 111u8, 109u8, 47u8, 112u8, 114u8, 111u8, + 116u8, 111u8, 99u8, 111u8, 108u8, 45u8, 98u8, 117u8, 102u8, 102u8, 101u8, + 114u8, 115u8, 47u8, 10u8, 10u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, + 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 32u8, 97u8, + 110u8, 100u8, 32u8, 117u8, 115u8, 101u8, 32u8, 105u8, 110u8, 32u8, 115u8, + 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 97u8, 110u8, 100u8, 32u8, 98u8, + 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, 109u8, 115u8, + 44u8, 32u8, 119u8, 105u8, 116u8, 104u8, 32u8, 111u8, 114u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 10u8, 32u8, 109u8, 111u8, 100u8, + 105u8, 102u8, 105u8, 99u8, 97u8, 116u8, 105u8, 111u8, 110u8, 44u8, 32u8, + 97u8, 114u8, 101u8, 32u8, 112u8, 101u8, 114u8, 109u8, 105u8, 116u8, 116u8, + 101u8, 100u8, 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, + 32u8, 116u8, 104u8, 97u8, 116u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, + 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 99u8, 111u8, + 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 97u8, 114u8, + 101u8, 10u8, 32u8, 109u8, 101u8, 116u8, 58u8, 10u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 111u8, 102u8, + 32u8, 115u8, 111u8, 117u8, 114u8, 99u8, 101u8, 32u8, 99u8, 111u8, 100u8, + 101u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 116u8, 97u8, + 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 111u8, 118u8, + 101u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, 105u8, 103u8, 104u8, 116u8, + 10u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, 44u8, 32u8, 116u8, + 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, 32u8, 111u8, 102u8, + 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, 111u8, 110u8, 115u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, 32u8, 102u8, 111u8, + 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, 100u8, 105u8, 115u8, + 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 46u8, 10u8, 32u8, 32u8, 32u8, + 32u8, 32u8, 42u8, 32u8, 82u8, 101u8, 100u8, 105u8, 115u8, 116u8, 114u8, + 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 115u8, 32u8, 105u8, 110u8, + 32u8, 98u8, 105u8, 110u8, 97u8, 114u8, 121u8, 32u8, 102u8, 111u8, 114u8, + 109u8, 32u8, 109u8, 117u8, 115u8, 116u8, 32u8, 114u8, 101u8, 112u8, 114u8, + 111u8, 100u8, 117u8, 99u8, 101u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, + 98u8, 111u8, 118u8, 101u8, 10u8, 32u8, 99u8, 111u8, 112u8, 121u8, 114u8, + 105u8, 103u8, 104u8, 116u8, 32u8, 110u8, 111u8, 116u8, 105u8, 99u8, 101u8, + 44u8, 32u8, 116u8, 104u8, 105u8, 115u8, 32u8, 108u8, 105u8, 115u8, 116u8, + 32u8, 111u8, 102u8, 32u8, 99u8, 111u8, 110u8, 100u8, 105u8, 116u8, 105u8, + 111u8, 110u8, 115u8, 32u8, 97u8, 110u8, 100u8, 32u8, 116u8, 104u8, 101u8, + 32u8, 102u8, 111u8, 108u8, 108u8, 111u8, 119u8, 105u8, 110u8, 103u8, 32u8, + 100u8, 105u8, 115u8, 99u8, 108u8, 97u8, 105u8, 109u8, 101u8, 114u8, 10u8, + 32u8, 105u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 100u8, 111u8, 99u8, + 117u8, 109u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, + 97u8, 110u8, 100u8, 47u8, 111u8, 114u8, 32u8, 111u8, 116u8, 104u8, 101u8, + 114u8, 32u8, 109u8, 97u8, 116u8, 101u8, 114u8, 105u8, 97u8, 108u8, 115u8, + 32u8, 112u8, 114u8, 111u8, 118u8, 105u8, 100u8, 101u8, 100u8, 32u8, 119u8, + 105u8, 116u8, 104u8, 32u8, 116u8, 104u8, 101u8, 10u8, 32u8, 100u8, 105u8, + 115u8, 116u8, 114u8, 105u8, 98u8, 117u8, 116u8, 105u8, 111u8, 110u8, 46u8, + 10u8, 32u8, 32u8, 32u8, 32u8, 32u8, 42u8, 32u8, 78u8, 101u8, 105u8, 116u8, + 104u8, 101u8, 114u8, 32u8, 116u8, 104u8, 101u8, 32u8, 110u8, 97u8, 109u8, + 101u8, 32u8, 111u8, 102u8, 32u8, 71u8, 111u8, 111u8, 103u8, 108u8, 101u8, + 32u8, 73u8, 110u8, 99u8, 46u8, 32u8, 110u8, 111u8, 114u8, 32u8, 116u8, 104u8, + 101u8, 32u8, 110u8, 97u8, 109u8, 101u8, 115u8, 32u8, 111u8, 102u8, 32u8, + 105u8, 116u8, 115u8, 10u8, 32u8, 99u8, 111u8, 110u8, 116u8, 114u8, 105u8, + 98u8, 117u8, 116u8, 111u8, 114u8, 115u8, 32u8, 109u8, 97u8, 121u8, 32u8, + 98u8, 101u8, 32u8, 117u8, 115u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, + 101u8, 110u8, 100u8, 111u8, 114u8, 115u8, 101u8, 32u8, 111u8, 114u8, 32u8, + 112u8, 114u8, 111u8, 109u8, 111u8, 116u8, 101u8, 32u8, 112u8, 114u8, 111u8, + 100u8, 117u8, 99u8, 116u8, 115u8, 32u8, 100u8, 101u8, 114u8, 105u8, 118u8, + 101u8, 100u8, 32u8, 102u8, 114u8, 111u8, 109u8, 10u8, 32u8, 116u8, 104u8, + 105u8, 115u8, 32u8, 115u8, 111u8, 102u8, 116u8, 119u8, 97u8, 114u8, 101u8, + 32u8, 119u8, 105u8, 116u8, 104u8, 111u8, 117u8, 116u8, 32u8, 115u8, 112u8, + 101u8, 99u8, 105u8, 102u8, 105u8, 99u8, 32u8, 112u8, 114u8, 105u8, 111u8, + 114u8, 32u8, 119u8, 114u8, 105u8, 116u8, 116u8, 101u8, 110u8, 32u8, 112u8, + 101u8, 114u8, 109u8, 105u8, 115u8, 115u8, 105u8, 111u8, 110u8, 46u8, 10u8, + 10u8, 32u8, 84u8, 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, + 82u8, 69u8, 32u8, 73u8, 83u8, 32u8, 80u8, 82u8, 79u8, 86u8, 73u8, 68u8, 69u8, + 68u8, 32u8, 66u8, 89u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, + 82u8, 73u8, 71u8, 72u8, 84u8, 32u8, 72u8, 79u8, 76u8, 68u8, 69u8, 82u8, 83u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, + 84u8, 79u8, 82u8, 83u8, 10u8, 32u8, 34u8, 65u8, 83u8, 32u8, 73u8, 83u8, 34u8, + 32u8, 65u8, 78u8, 68u8, 32u8, 65u8, 78u8, 89u8, 32u8, 69u8, 88u8, 80u8, 82u8, + 69u8, 83u8, 83u8, 32u8, 79u8, 82u8, 32u8, 73u8, 77u8, 80u8, 76u8, 73u8, 69u8, + 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, 73u8, 69u8, 83u8, 44u8, + 32u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, 44u8, 32u8, 66u8, + 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, 76u8, 73u8, 77u8, 73u8, 84u8, + 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 84u8, 72u8, 69u8, 32u8, 73u8, 77u8, + 80u8, 76u8, 73u8, 69u8, 68u8, 32u8, 87u8, 65u8, 82u8, 82u8, 65u8, 78u8, 84u8, + 73u8, 69u8, 83u8, 32u8, 79u8, 70u8, 32u8, 77u8, 69u8, 82u8, 67u8, 72u8, 65u8, + 78u8, 84u8, 65u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 65u8, 78u8, 68u8, + 32u8, 70u8, 73u8, 84u8, 78u8, 69u8, 83u8, 83u8, 32u8, 70u8, 79u8, 82u8, 10u8, + 32u8, 65u8, 32u8, 80u8, 65u8, 82u8, 84u8, 73u8, 67u8, 85u8, 76u8, 65u8, 82u8, + 32u8, 80u8, 85u8, 82u8, 80u8, 79u8, 83u8, 69u8, 32u8, 65u8, 82u8, 69u8, 32u8, + 68u8, 73u8, 83u8, 67u8, 76u8, 65u8, 73u8, 77u8, 69u8, 68u8, 46u8, 32u8, 73u8, + 78u8, 32u8, 78u8, 79u8, 32u8, 69u8, 86u8, 69u8, 78u8, 84u8, 32u8, 83u8, 72u8, + 65u8, 76u8, 76u8, 32u8, 84u8, 72u8, 69u8, 32u8, 67u8, 79u8, 80u8, 89u8, 82u8, + 73u8, 71u8, 72u8, 84u8, 10u8, 32u8, 79u8, 87u8, 78u8, 69u8, 82u8, 32u8, 79u8, + 82u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 73u8, 66u8, 85u8, 84u8, 79u8, 82u8, + 83u8, 32u8, 66u8, 69u8, 32u8, 76u8, 73u8, 65u8, 66u8, 76u8, 69u8, 32u8, 70u8, + 79u8, 82u8, 32u8, 65u8, 78u8, 89u8, 32u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, + 44u8, 32u8, 73u8, 78u8, 68u8, 73u8, 82u8, 69u8, 67u8, 84u8, 44u8, 32u8, 73u8, + 78u8, 67u8, 73u8, 68u8, 69u8, 78u8, 84u8, 65u8, 76u8, 44u8, 10u8, 32u8, 83u8, + 80u8, 69u8, 67u8, 73u8, 65u8, 76u8, 44u8, 32u8, 69u8, 88u8, 69u8, 77u8, 80u8, + 76u8, 65u8, 82u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 67u8, 79u8, 78u8, 83u8, + 69u8, 81u8, 85u8, 69u8, 78u8, 84u8, 73u8, 65u8, 76u8, 32u8, 68u8, 65u8, 77u8, + 65u8, 71u8, 69u8, 83u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, + 78u8, 71u8, 44u8, 32u8, 66u8, 85u8, 84u8, 32u8, 78u8, 79u8, 84u8, 10u8, 32u8, + 76u8, 73u8, 77u8, 73u8, 84u8, 69u8, 68u8, 32u8, 84u8, 79u8, 44u8, 32u8, 80u8, + 82u8, 79u8, 67u8, 85u8, 82u8, 69u8, 77u8, 69u8, 78u8, 84u8, 32u8, 79u8, 70u8, + 32u8, 83u8, 85u8, 66u8, 83u8, 84u8, 73u8, 84u8, 85u8, 84u8, 69u8, 32u8, 71u8, + 79u8, 79u8, 68u8, 83u8, 32u8, 79u8, 82u8, 32u8, 83u8, 69u8, 82u8, 86u8, 73u8, + 67u8, 69u8, 83u8, 59u8, 32u8, 76u8, 79u8, 83u8, 83u8, 32u8, 79u8, 70u8, 32u8, + 85u8, 83u8, 69u8, 44u8, 10u8, 32u8, 68u8, 65u8, 84u8, 65u8, 44u8, 32u8, 79u8, + 82u8, 32u8, 80u8, 82u8, 79u8, 70u8, 73u8, 84u8, 83u8, 59u8, 32u8, 79u8, 82u8, + 32u8, 66u8, 85u8, 83u8, 73u8, 78u8, 69u8, 83u8, 83u8, 32u8, 73u8, 78u8, 84u8, + 69u8, 82u8, 82u8, 85u8, 80u8, 84u8, 73u8, 79u8, 78u8, 41u8, 32u8, 72u8, 79u8, + 87u8, 69u8, 86u8, 69u8, 82u8, 32u8, 67u8, 65u8, 85u8, 83u8, 69u8, 68u8, 32u8, + 65u8, 78u8, 68u8, 32u8, 79u8, 78u8, 32u8, 65u8, 78u8, 89u8, 10u8, 32u8, 84u8, + 72u8, 69u8, 79u8, 82u8, 89u8, 32u8, 79u8, 70u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 87u8, 72u8, 69u8, 84u8, 72u8, 69u8, + 82u8, 32u8, 73u8, 78u8, 32u8, 67u8, 79u8, 78u8, 84u8, 82u8, 65u8, 67u8, 84u8, + 44u8, 32u8, 83u8, 84u8, 82u8, 73u8, 67u8, 84u8, 32u8, 76u8, 73u8, 65u8, 66u8, + 73u8, 76u8, 73u8, 84u8, 89u8, 44u8, 32u8, 79u8, 82u8, 32u8, 84u8, 79u8, 82u8, + 84u8, 10u8, 32u8, 40u8, 73u8, 78u8, 67u8, 76u8, 85u8, 68u8, 73u8, 78u8, 71u8, + 32u8, 78u8, 69u8, 71u8, 76u8, 73u8, 71u8, 69u8, 78u8, 67u8, 69u8, 32u8, 79u8, + 82u8, 32u8, 79u8, 84u8, 72u8, 69u8, 82u8, 87u8, 73u8, 83u8, 69u8, 41u8, 32u8, + 65u8, 82u8, 73u8, 83u8, 73u8, 78u8, 71u8, 32u8, 73u8, 78u8, 32u8, 65u8, 78u8, + 89u8, 32u8, 87u8, 65u8, 89u8, 32u8, 79u8, 85u8, 84u8, 32u8, 79u8, 70u8, 32u8, + 84u8, 72u8, 69u8, 32u8, 85u8, 83u8, 69u8, 10u8, 32u8, 79u8, 70u8, 32u8, 84u8, + 72u8, 73u8, 83u8, 32u8, 83u8, 79u8, 70u8, 84u8, 87u8, 65u8, 82u8, 69u8, 44u8, + 32u8, 69u8, 86u8, 69u8, 78u8, 32u8, 73u8, 70u8, 32u8, 65u8, 68u8, 86u8, 73u8, + 83u8, 69u8, 68u8, 32u8, 79u8, 70u8, 32u8, 84u8, 72u8, 69u8, 32u8, 80u8, 79u8, + 83u8, 83u8, 73u8, 66u8, 73u8, 76u8, 73u8, 84u8, 89u8, 32u8, 79u8, 70u8, 32u8, + 83u8, 85u8, 67u8, 72u8, 32u8, 68u8, 65u8, 77u8, 65u8, 71u8, 69u8, 46u8, 10u8, + 10u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 115u8, 32u8, + 102u8, 111u8, 114u8, 32u8, 112u8, 114u8, 105u8, 109u8, 105u8, 116u8, 105u8, + 118u8, 101u8, 32u8, 40u8, 110u8, 111u8, 110u8, 45u8, 109u8, 101u8, 115u8, + 115u8, 97u8, 103u8, 101u8, 41u8, 32u8, 116u8, 121u8, 112u8, 101u8, 115u8, + 46u8, 32u8, 84u8, 104u8, 101u8, 115u8, 101u8, 32u8, 116u8, 121u8, 112u8, + 101u8, 115u8, 32u8, 97u8, 114u8, 101u8, 32u8, 117u8, 115u8, 101u8, 102u8, + 117u8, 108u8, 10u8, 32u8, 102u8, 111u8, 114u8, 32u8, 101u8, 109u8, 98u8, + 101u8, 100u8, 100u8, 105u8, 110u8, 103u8, 32u8, 112u8, 114u8, 105u8, 109u8, + 105u8, 116u8, 105u8, 118u8, 101u8, 115u8, 32u8, 105u8, 110u8, 32u8, 116u8, + 104u8, 101u8, 32u8, 96u8, 103u8, 111u8, 111u8, 103u8, 108u8, 101u8, 46u8, + 112u8, 114u8, 111u8, 116u8, 111u8, 98u8, 117u8, 102u8, 46u8, 65u8, 110u8, + 121u8, 96u8, 32u8, 116u8, 121u8, 112u8, 101u8, 32u8, 97u8, 110u8, 100u8, + 32u8, 102u8, 111u8, 114u8, 32u8, 112u8, 108u8, 97u8, 99u8, 101u8, 115u8, + 10u8, 32u8, 119u8, 104u8, 101u8, 114u8, 101u8, 32u8, 119u8, 101u8, 32u8, + 110u8, 101u8, 101u8, 100u8, 32u8, 116u8, 111u8, 32u8, 100u8, 105u8, 115u8, + 116u8, 105u8, 110u8, 103u8, 117u8, 105u8, 115u8, 104u8, 32u8, 98u8, 101u8, + 116u8, 119u8, 101u8, 101u8, 110u8, 32u8, 116u8, 104u8, 101u8, 32u8, 97u8, + 98u8, 115u8, 101u8, 110u8, 99u8, 101u8, 32u8, 111u8, 102u8, 32u8, 97u8, 32u8, + 112u8, 114u8, 105u8, 109u8, 105u8, 116u8, 105u8, 118u8, 101u8, 10u8, 32u8, + 116u8, 121u8, 112u8, 101u8, 100u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, + 32u8, 97u8, 110u8, 100u8, 32u8, 105u8, 116u8, 115u8, 32u8, 100u8, 101u8, + 102u8, 97u8, 117u8, 108u8, 116u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 115u8, 101u8, 32u8, 119u8, 114u8, + 97u8, 112u8, 112u8, 101u8, 114u8, 115u8, 32u8, 104u8, 97u8, 118u8, 101u8, + 32u8, 110u8, 111u8, 32u8, 109u8, 101u8, 97u8, 110u8, 105u8, 110u8, 103u8, + 102u8, 117u8, 108u8, 32u8, 117u8, 115u8, 101u8, 32u8, 119u8, 105u8, 116u8, + 104u8, 105u8, 110u8, 32u8, 114u8, 101u8, 112u8, 101u8, 97u8, 116u8, 101u8, + 100u8, 32u8, 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 97u8, 115u8, + 32u8, 116u8, 104u8, 101u8, 121u8, 32u8, 108u8, 97u8, 99u8, 107u8, 10u8, 32u8, + 116u8, 104u8, 101u8, 32u8, 97u8, 98u8, 105u8, 108u8, 105u8, 116u8, 121u8, + 32u8, 116u8, 111u8, 32u8, 100u8, 101u8, 116u8, 101u8, 99u8, 116u8, 32u8, + 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 99u8, 101u8, 32u8, 111u8, 110u8, + 32u8, 105u8, 110u8, 100u8, 105u8, 118u8, 105u8, 100u8, 117u8, 97u8, 108u8, + 32u8, 101u8, 108u8, 101u8, 109u8, 101u8, 110u8, 116u8, 115u8, 46u8, 10u8, + 32u8, 84u8, 104u8, 101u8, 115u8, 101u8, 32u8, 119u8, 114u8, 97u8, 112u8, + 112u8, 101u8, 114u8, 115u8, 32u8, 104u8, 97u8, 118u8, 101u8, 32u8, 110u8, + 111u8, 32u8, 109u8, 101u8, 97u8, 110u8, 105u8, 110u8, 103u8, 102u8, 117u8, + 108u8, 32u8, 117u8, 115u8, 101u8, 32u8, 119u8, 105u8, 116u8, 104u8, 105u8, + 110u8, 32u8, 97u8, 32u8, 109u8, 97u8, 112u8, 32u8, 111u8, 114u8, 32u8, 97u8, + 32u8, 111u8, 110u8, 101u8, 111u8, 102u8, 32u8, 115u8, 105u8, 110u8, 99u8, + 101u8, 10u8, 32u8, 105u8, 110u8, 100u8, 105u8, 118u8, 105u8, 100u8, 117u8, + 97u8, 108u8, 32u8, 101u8, 110u8, 116u8, 114u8, 105u8, 101u8, 115u8, 32u8, + 111u8, 102u8, 32u8, 97u8, 32u8, 109u8, 97u8, 112u8, 32u8, 111u8, 114u8, 32u8, + 102u8, 105u8, 101u8, 108u8, 100u8, 115u8, 32u8, 111u8, 102u8, 32u8, 97u8, + 32u8, 111u8, 110u8, 101u8, 111u8, 102u8, 32u8, 99u8, 97u8, 110u8, 32u8, 97u8, + 108u8, 114u8, 101u8, 97u8, 100u8, 121u8, 32u8, 100u8, 101u8, 116u8, 101u8, + 99u8, 116u8, 32u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 99u8, 101u8, + 46u8, 10u8, 10u8, 8u8, 10u8, 1u8, 2u8, 18u8, 3u8, 42u8, 0u8, 24u8, 10u8, 8u8, + 10u8, 1u8, 8u8, 18u8, 3u8, 44u8, 0u8, 31u8, 10u8, 9u8, 10u8, 2u8, 8u8, 31u8, + 18u8, 3u8, 44u8, 0u8, 31u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 45u8, 0u8, + 72u8, 10u8, 9u8, 10u8, 2u8, 8u8, 11u8, 18u8, 3u8, 45u8, 0u8, 72u8, 10u8, 8u8, + 10u8, 1u8, 8u8, 18u8, 3u8, 46u8, 0u8, 44u8, 10u8, 9u8, 10u8, 2u8, 8u8, 1u8, + 18u8, 3u8, 46u8, 0u8, 44u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 47u8, 0u8, + 46u8, 10u8, 9u8, 10u8, 2u8, 8u8, 8u8, 18u8, 3u8, 47u8, 0u8, 46u8, 10u8, 8u8, + 10u8, 1u8, 8u8, 18u8, 3u8, 48u8, 0u8, 34u8, 10u8, 9u8, 10u8, 2u8, 8u8, 10u8, + 18u8, 3u8, 48u8, 0u8, 34u8, 10u8, 8u8, 10u8, 1u8, 8u8, 18u8, 3u8, 49u8, 0u8, + 33u8, 10u8, 9u8, 10u8, 2u8, 8u8, 36u8, 18u8, 3u8, 49u8, 0u8, 33u8, 10u8, 8u8, + 10u8, 1u8, 8u8, 18u8, 3u8, 50u8, 0u8, 59u8, 10u8, 9u8, 10u8, 2u8, 8u8, 37u8, + 18u8, 3u8, 50u8, 0u8, 59u8, 10u8, 103u8, 10u8, 2u8, 4u8, 0u8, 18u8, 4u8, + 55u8, 0u8, 58u8, 1u8, 26u8, 91u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, + 101u8, 114u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, + 102u8, 111u8, 114u8, 32u8, 96u8, 100u8, 111u8, 117u8, 98u8, 108u8, 101u8, + 96u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, + 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, + 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, + 68u8, 111u8, 117u8, 98u8, 108u8, 101u8, 86u8, 97u8, 108u8, 117u8, 101u8, + 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 110u8, 117u8, + 109u8, 98u8, 101u8, 114u8, 46u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 0u8, 1u8, + 18u8, 3u8, 55u8, 8u8, 19u8, 10u8, 32u8, 10u8, 4u8, 4u8, 0u8, 2u8, 0u8, 18u8, + 3u8, 57u8, 2u8, 19u8, 26u8, 19u8, 32u8, 84u8, 104u8, 101u8, 32u8, 100u8, + 111u8, 117u8, 98u8, 108u8, 101u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 5u8, 18u8, 3u8, 57u8, + 2u8, 8u8, 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 1u8, 18u8, 3u8, 57u8, + 9u8, 14u8, 10u8, 12u8, 10u8, 5u8, 4u8, 0u8, 2u8, 0u8, 3u8, 18u8, 3u8, 57u8, + 17u8, 18u8, 10u8, 101u8, 10u8, 2u8, 4u8, 1u8, 18u8, 4u8, 63u8, 0u8, 66u8, + 1u8, 26u8, 89u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 32u8, + 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 102u8, 111u8, 114u8, + 32u8, 96u8, 102u8, 108u8, 111u8, 97u8, 116u8, 96u8, 46u8, 10u8, 10u8, 32u8, + 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, + 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, + 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, 70u8, 108u8, 111u8, 97u8, 116u8, 86u8, + 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, + 78u8, 32u8, 110u8, 117u8, 109u8, 98u8, 101u8, 114u8, 46u8, 10u8, 10u8, 10u8, + 10u8, 3u8, 4u8, 1u8, 1u8, 18u8, 3u8, 63u8, 8u8, 18u8, 10u8, 31u8, 10u8, 4u8, + 4u8, 1u8, 2u8, 0u8, 18u8, 3u8, 65u8, 2u8, 18u8, 26u8, 18u8, 32u8, 84u8, + 104u8, 101u8, 32u8, 102u8, 108u8, 111u8, 97u8, 116u8, 32u8, 118u8, 97u8, + 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 0u8, + 5u8, 18u8, 3u8, 65u8, 2u8, 7u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 0u8, + 1u8, 18u8, 3u8, 65u8, 8u8, 13u8, 10u8, 12u8, 10u8, 5u8, 4u8, 1u8, 2u8, 0u8, + 3u8, 18u8, 3u8, 65u8, 16u8, 17u8, 10u8, 101u8, 10u8, 2u8, 4u8, 2u8, 18u8, + 4u8, 71u8, 0u8, 74u8, 1u8, 26u8, 89u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, + 101u8, 114u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, + 102u8, 111u8, 114u8, 32u8, 96u8, 105u8, 110u8, 116u8, 54u8, 52u8, 96u8, 46u8, + 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, + 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, + 105u8, 111u8, 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, 73u8, 110u8, + 116u8, 54u8, 52u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, + 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, + 46u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 2u8, 1u8, 18u8, 3u8, 71u8, 8u8, 18u8, + 10u8, 31u8, 10u8, 4u8, 4u8, 2u8, 2u8, 0u8, 18u8, 3u8, 73u8, 2u8, 18u8, 26u8, + 18u8, 32u8, 84u8, 104u8, 101u8, 32u8, 105u8, 110u8, 116u8, 54u8, 52u8, 32u8, + 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, + 2u8, 2u8, 0u8, 5u8, 18u8, 3u8, 73u8, 2u8, 7u8, 10u8, 12u8, 10u8, 5u8, 4u8, + 2u8, 2u8, 0u8, 1u8, 18u8, 3u8, 73u8, 8u8, 13u8, 10u8, 12u8, 10u8, 5u8, 4u8, + 2u8, 2u8, 0u8, 3u8, 18u8, 3u8, 73u8, 16u8, 17u8, 10u8, 103u8, 10u8, 2u8, 4u8, + 3u8, 18u8, 4u8, 79u8, 0u8, 82u8, 1u8, 26u8, 91u8, 32u8, 87u8, 114u8, 97u8, + 112u8, 112u8, 101u8, 114u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, + 101u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, 117u8, 105u8, 110u8, 116u8, + 54u8, 52u8, 96u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, + 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, + 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, 111u8, 114u8, + 32u8, 96u8, 85u8, 73u8, 110u8, 116u8, 54u8, 52u8, 86u8, 97u8, 108u8, 117u8, + 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 115u8, + 116u8, 114u8, 105u8, 110u8, 103u8, 46u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, + 3u8, 1u8, 18u8, 3u8, 79u8, 8u8, 19u8, 10u8, 32u8, 10u8, 4u8, 4u8, 3u8, 2u8, + 0u8, 18u8, 3u8, 81u8, 2u8, 19u8, 26u8, 19u8, 32u8, 84u8, 104u8, 101u8, 32u8, + 117u8, 105u8, 110u8, 116u8, 54u8, 52u8, 32u8, 118u8, 97u8, 108u8, 117u8, + 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 3u8, 2u8, 0u8, 5u8, 18u8, 3u8, + 81u8, 2u8, 8u8, 10u8, 12u8, 10u8, 5u8, 4u8, 3u8, 2u8, 0u8, 1u8, 18u8, 3u8, + 81u8, 9u8, 14u8, 10u8, 12u8, 10u8, 5u8, 4u8, 3u8, 2u8, 0u8, 3u8, 18u8, 3u8, + 81u8, 17u8, 18u8, 10u8, 101u8, 10u8, 2u8, 4u8, 4u8, 18u8, 4u8, 87u8, 0u8, + 90u8, 1u8, 26u8, 89u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, + 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 102u8, 111u8, + 114u8, 32u8, 96u8, 105u8, 110u8, 116u8, 51u8, 50u8, 96u8, 46u8, 10u8, 10u8, + 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, + 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, + 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, 73u8, 110u8, 116u8, 51u8, 50u8, + 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, + 79u8, 78u8, 32u8, 110u8, 117u8, 109u8, 98u8, 101u8, 114u8, 46u8, 10u8, 10u8, + 10u8, 10u8, 3u8, 4u8, 4u8, 1u8, 18u8, 3u8, 87u8, 8u8, 18u8, 10u8, 31u8, 10u8, + 4u8, 4u8, 4u8, 2u8, 0u8, 18u8, 3u8, 89u8, 2u8, 18u8, 26u8, 18u8, 32u8, 84u8, + 104u8, 101u8, 32u8, 105u8, 110u8, 116u8, 51u8, 50u8, 32u8, 118u8, 97u8, + 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 4u8, 2u8, 0u8, + 5u8, 18u8, 3u8, 89u8, 2u8, 7u8, 10u8, 12u8, 10u8, 5u8, 4u8, 4u8, 2u8, 0u8, + 1u8, 18u8, 3u8, 89u8, 8u8, 13u8, 10u8, 12u8, 10u8, 5u8, 4u8, 4u8, 2u8, 0u8, + 3u8, 18u8, 3u8, 89u8, 16u8, 17u8, 10u8, 103u8, 10u8, 2u8, 4u8, 5u8, 18u8, + 4u8, 95u8, 0u8, 98u8, 1u8, 26u8, 91u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, + 101u8, 114u8, 32u8, 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, + 102u8, 111u8, 114u8, 32u8, 96u8, 117u8, 105u8, 110u8, 116u8, 51u8, 50u8, + 96u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, + 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, + 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, + 85u8, 73u8, 110u8, 116u8, 51u8, 50u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, + 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 110u8, 117u8, 109u8, + 98u8, 101u8, 114u8, 46u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 5u8, 1u8, 18u8, + 3u8, 95u8, 8u8, 19u8, 10u8, 32u8, 10u8, 4u8, 4u8, 5u8, 2u8, 0u8, 18u8, 3u8, + 97u8, 2u8, 19u8, 26u8, 19u8, 32u8, 84u8, 104u8, 101u8, 32u8, 117u8, 105u8, + 110u8, 116u8, 51u8, 50u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, 10u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 5u8, 2u8, 0u8, 5u8, 18u8, 3u8, 97u8, 2u8, 8u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 5u8, 2u8, 0u8, 1u8, 18u8, 3u8, 97u8, 9u8, 14u8, + 10u8, 12u8, 10u8, 5u8, 4u8, 5u8, 2u8, 0u8, 3u8, 18u8, 3u8, 97u8, 17u8, 18u8, + 10u8, 111u8, 10u8, 2u8, 4u8, 6u8, 18u8, 4u8, 103u8, 0u8, 106u8, 1u8, 26u8, + 99u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 32u8, 109u8, + 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 102u8, 111u8, 114u8, 32u8, + 96u8, 98u8, 111u8, 111u8, 108u8, 96u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, + 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, + 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, + 111u8, 114u8, 32u8, 96u8, 66u8, 111u8, 111u8, 108u8, 86u8, 97u8, 108u8, + 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, + 96u8, 116u8, 114u8, 117u8, 101u8, 96u8, 32u8, 97u8, 110u8, 100u8, 32u8, 96u8, + 102u8, 97u8, 108u8, 115u8, 101u8, 96u8, 46u8, 10u8, 10u8, 10u8, 10u8, 3u8, + 4u8, 6u8, 1u8, 18u8, 3u8, 103u8, 8u8, 17u8, 10u8, 30u8, 10u8, 4u8, 4u8, 6u8, + 2u8, 0u8, 18u8, 3u8, 105u8, 2u8, 17u8, 26u8, 17u8, 32u8, 84u8, 104u8, 101u8, + 32u8, 98u8, 111u8, 111u8, 108u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, + 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 6u8, 2u8, 0u8, 5u8, 18u8, 3u8, 105u8, + 2u8, 6u8, 10u8, 12u8, 10u8, 5u8, 4u8, 6u8, 2u8, 0u8, 1u8, 18u8, 3u8, 105u8, + 7u8, 12u8, 10u8, 12u8, 10u8, 5u8, 4u8, 6u8, 2u8, 0u8, 3u8, 18u8, 3u8, 105u8, + 15u8, 16u8, 10u8, 103u8, 10u8, 2u8, 4u8, 7u8, 18u8, 4u8, 111u8, 0u8, 114u8, + 1u8, 26u8, 91u8, 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 32u8, + 109u8, 101u8, 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 102u8, 111u8, 114u8, + 32u8, 96u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 96u8, 46u8, 10u8, 10u8, + 32u8, 84u8, 104u8, 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, + 112u8, 114u8, 101u8, 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, + 110u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, 83u8, 116u8, 114u8, 105u8, + 110u8, 103u8, 86u8, 97u8, 108u8, 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, + 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, + 46u8, 10u8, 10u8, 10u8, 10u8, 3u8, 4u8, 7u8, 1u8, 18u8, 3u8, 111u8, 8u8, + 19u8, 10u8, 32u8, 10u8, 4u8, 4u8, 7u8, 2u8, 0u8, 18u8, 3u8, 113u8, 2u8, 19u8, + 26u8, 19u8, 32u8, 84u8, 104u8, 101u8, 32u8, 115u8, 116u8, 114u8, 105u8, + 110u8, 103u8, 32u8, 118u8, 97u8, 108u8, 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, + 10u8, 5u8, 4u8, 7u8, 2u8, 0u8, 5u8, 18u8, 3u8, 113u8, 2u8, 8u8, 10u8, 12u8, + 10u8, 5u8, 4u8, 7u8, 2u8, 0u8, 1u8, 18u8, 3u8, 113u8, 9u8, 14u8, 10u8, 12u8, + 10u8, 5u8, 4u8, 7u8, 2u8, 0u8, 3u8, 18u8, 3u8, 113u8, 17u8, 18u8, 10u8, + 101u8, 10u8, 2u8, 4u8, 8u8, 18u8, 4u8, 119u8, 0u8, 122u8, 1u8, 26u8, 89u8, + 32u8, 87u8, 114u8, 97u8, 112u8, 112u8, 101u8, 114u8, 32u8, 109u8, 101u8, + 115u8, 115u8, 97u8, 103u8, 101u8, 32u8, 102u8, 111u8, 114u8, 32u8, 96u8, + 98u8, 121u8, 116u8, 101u8, 115u8, 96u8, 46u8, 10u8, 10u8, 32u8, 84u8, 104u8, + 101u8, 32u8, 74u8, 83u8, 79u8, 78u8, 32u8, 114u8, 101u8, 112u8, 114u8, 101u8, + 115u8, 101u8, 110u8, 116u8, 97u8, 116u8, 105u8, 111u8, 110u8, 32u8, 102u8, + 111u8, 114u8, 32u8, 96u8, 66u8, 121u8, 116u8, 101u8, 115u8, 86u8, 97u8, + 108u8, 117u8, 101u8, 96u8, 32u8, 105u8, 115u8, 32u8, 74u8, 83u8, 79u8, 78u8, + 32u8, 115u8, 116u8, 114u8, 105u8, 110u8, 103u8, 46u8, 10u8, 10u8, 10u8, 10u8, + 3u8, 4u8, 8u8, 1u8, 18u8, 3u8, 119u8, 8u8, 18u8, 10u8, 31u8, 10u8, 4u8, 4u8, + 8u8, 2u8, 0u8, 18u8, 3u8, 121u8, 2u8, 18u8, 26u8, 18u8, 32u8, 84u8, 104u8, + 101u8, 32u8, 98u8, 121u8, 116u8, 101u8, 115u8, 32u8, 118u8, 97u8, 108u8, + 117u8, 101u8, 46u8, 10u8, 10u8, 12u8, 10u8, 5u8, 4u8, 8u8, 2u8, 0u8, 5u8, + 18u8, 3u8, 121u8, 2u8, 7u8, 10u8, 12u8, 10u8, 5u8, 4u8, 8u8, 2u8, 0u8, 1u8, + 18u8, 3u8, 121u8, 8u8, 13u8, 10u8, 12u8, 10u8, 5u8, 4u8, 8u8, 2u8, 0u8, 3u8, + 18u8, 3u8, 121u8, 16u8, 17u8, 98u8, 6u8, 112u8, 114u8, 111u8, 116u8, 111u8, + 51u8, + ]; + /// The lazily-built descriptor pool for this package's + /// `Reflectable` impls. Built from + /// [`FILE_DESCRIPTOR_SET_BYTES`] on first access. + /// + /// # Panics + /// + /// Panics on first access if the embedded bytes are malformed — + /// they're emitted by `buffa-codegen` from the same descriptors + /// it generated this code from, so a panic indicates a codegen + /// bug, not consumer input. + pub fn descriptor_pool() -> &'static ::buffa::alloc::sync::Arc< + ::buffa_descriptor::DescriptorPool, + > { + static POOL: ::std::sync::OnceLock< + ::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool>, + > = ::std::sync::OnceLock::new(); + POOL.get_or_init(|| { + ::buffa::alloc::sync::Arc::new( + ::buffa_descriptor::DescriptorPool::decode(FILE_DESCRIPTOR_SET_BYTES) + .expect("embedded FileDescriptorSet is well-formed"), + ) + }) + } + } } +#[cfg(feature = "reflect")] +///The lazily-built descriptor pool for this package's +///`Reflectable` impls. Re-exported from `__buffa::reflect`. +pub use __buffa::reflect::descriptor_pool; #[doc(inline)] pub use self::__buffa::view::AnyView; #[doc(inline)] diff --git a/buffa-types/src/generated/google.protobuf.struct.__view.rs b/buffa-types/src/generated/google.protobuf.struct.__view.rs index ac264dc..37f5804 100644 --- a/buffa-types/src/generated/google.protobuf.struct.__view.rs +++ b/buffa-types/src/generated/google.protobuf.struct.__view.rs @@ -246,6 +246,96 @@ impl ::buffa::ViewReborrow for StructView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for StructView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::Map(&self.fields), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !::buffa::MapView::is_empty(&self.fields), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for StructView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> StructView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// `Value` represents a dynamically typed value which can be either /// null, a number, a string, a boolean, a recursive struct value, or a /// list of values. A producer of value is expected to set one of these @@ -624,6 +714,210 @@ impl ::buffa::ViewReborrow for ValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for ValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => { + match &self.kind { + ::core::option::Option::Some( + super::super::__buffa::view::oneof::value::Kind::NullValue(v), + ) => { + ::buffa_descriptor::reflect::ValueRef::EnumNumber(v.to_i32()) + } + _ => ::buffa_descriptor::reflect::ValueRef::EnumNumber(0), + } + } + 2u32 => { + match &self.kind { + ::core::option::Option::Some( + super::super::__buffa::view::oneof::value::Kind::NumberValue( + v, + ), + ) => ::buffa_descriptor::reflect::ValueRef::F64(*v), + _ => ::buffa_descriptor::reflect::ValueRef::F64(0.0), + } + } + 3u32 => { + match &self.kind { + ::core::option::Option::Some( + super::super::__buffa::view::oneof::value::Kind::StringValue( + v, + ), + ) => ::buffa_descriptor::reflect::ValueRef::String(v), + _ => ::buffa_descriptor::reflect::ValueRef::String(""), + } + } + 4u32 => { + match &self.kind { + ::core::option::Option::Some( + super::super::__buffa::view::oneof::value::Kind::BoolValue(v), + ) => ::buffa_descriptor::reflect::ValueRef::Bool(*v), + _ => ::buffa_descriptor::reflect::ValueRef::Bool(false), + } + } + 5u32 => { + match &self.kind { + ::core::option::Option::Some( + super::super::__buffa::view::oneof::value::Kind::StructValue( + v, + ), + ) => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(&**v), + ) + } + _ => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed( + as ::buffa::view::DefaultViewInstance>::default_view_instance(), + ), + ) + } + } + } + 6u32 => { + match &self.kind { + ::core::option::Option::Some( + super::super::__buffa::view::oneof::value::Kind::ListValue(v), + ) => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(&**v), + ) + } + _ => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed( + as ::buffa::view::DefaultViewInstance>::default_view_instance(), + ), + ) + } + } + } + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(super::super::__buffa::view::oneof::value::Kind::NullValue(_)) + ) + } + 2u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(super::super::__buffa::view::oneof::value::Kind::NumberValue(_)) + ) + } + 3u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(super::super::__buffa::view::oneof::value::Kind::StringValue(_)) + ) + } + 4u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(super::super::__buffa::view::oneof::value::Kind::BoolValue(_)) + ) + } + 5u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(super::super::__buffa::view::oneof::value::Kind::StructValue(_)) + ) + } + 6u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(super::super::__buffa::view::oneof::value::Kind::ListValue(_)) + ) + } + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for ValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> ValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// `ListValue` is a wrapper around a repeated field of values. /// /// The JSON representation for `ListValue` is JSON array. @@ -801,3 +1095,93 @@ impl ::buffa::ViewReborrow for ListValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for ListValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::List(&self.values), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !::buffa::RepeatedView::is_empty(&self.values), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for ListValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> ListValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; diff --git a/buffa-types/src/generated/google.protobuf.struct.rs b/buffa-types/src/generated/google.protobuf.struct.rs index d35f48a..ad4f3e2 100644 --- a/buffa-types/src/generated/google.protobuf.struct.rs +++ b/buffa-types/src/generated/google.protobuf.struct.rs @@ -78,6 +78,49 @@ impl ::buffa::DefaultInstance for Struct { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Struct { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Struct { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Struct"; @@ -355,6 +398,49 @@ impl ::buffa::DefaultInstance for Value { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Value { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Value"; @@ -772,6 +858,49 @@ impl ::buffa::DefaultInstance for ListValue { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for ListValue { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for ListValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "ListValue"; diff --git a/buffa-types/src/generated/google.protobuf.timestamp.__view.rs b/buffa-types/src/generated/google.protobuf.timestamp.__view.rs index f3f0e6e..bd0ba35 100644 --- a/buffa-types/src/generated/google.protobuf.timestamp.__view.rs +++ b/buffa-types/src/generated/google.protobuf.timestamp.__view.rs @@ -281,3 +281,95 @@ impl ::buffa::ViewReborrow for TimestampView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for TimestampView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I64(self.seconds), + 2u32 => ::buffa_descriptor::reflect::ValueRef::I32(self.nanos), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.seconds != 0, + 2u32 => self.nanos != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for TimestampView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> TimestampView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; diff --git a/buffa-types/src/generated/google.protobuf.timestamp.rs b/buffa-types/src/generated/google.protobuf.timestamp.rs index 2c5101f..9001ec2 100644 --- a/buffa-types/src/generated/google.protobuf.timestamp.rs +++ b/buffa-types/src/generated/google.protobuf.timestamp.rs @@ -142,6 +142,49 @@ impl ::buffa::DefaultInstance for Timestamp { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Timestamp { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Timestamp { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Timestamp"; diff --git a/buffa-types/src/generated/google.protobuf.wrappers.__view.rs b/buffa-types/src/generated/google.protobuf.wrappers.__view.rs index e9a8be4..1793e64 100644 --- a/buffa-types/src/generated/google.protobuf.wrappers.__view.rs +++ b/buffa-types/src/generated/google.protobuf.wrappers.__view.rs @@ -155,6 +155,96 @@ impl ::buffa::ViewReborrow for DoubleValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for DoubleValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::F64(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0.0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for DoubleValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> DoubleValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `float`. /// /// The JSON representation for `FloatValue` is JSON number. @@ -309,6 +399,96 @@ impl ::buffa::ViewReborrow for FloatValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for FloatValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::F32(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0.0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for FloatValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> FloatValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `int64`. /// /// The JSON representation for `Int64Value` is JSON string. @@ -463,6 +643,96 @@ impl ::buffa::ViewReborrow for Int64ValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for Int64ValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I64(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for Int64ValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> Int64ValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `uint64`. /// /// The JSON representation for `UInt64Value` is JSON string. @@ -617,6 +887,96 @@ impl ::buffa::ViewReborrow for UInt64ValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for UInt64ValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::U64(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for UInt64ValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> UInt64ValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `int32`. /// /// The JSON representation for `Int32Value` is JSON number. @@ -771,6 +1131,96 @@ impl ::buffa::ViewReborrow for Int32ValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for Int32ValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I32(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for Int32ValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> Int32ValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `uint32`. /// /// The JSON representation for `UInt32Value` is JSON number. @@ -925,6 +1375,96 @@ impl ::buffa::ViewReborrow for UInt32ValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for UInt32ValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::U32(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for UInt32ValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> UInt32ValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `bool`. /// /// The JSON representation for `BoolValue` is JSON `true` and `false`. @@ -1079,6 +1619,96 @@ impl ::buffa::ViewReborrow for BoolValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for BoolValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::Bool(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for BoolValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> BoolValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `string`. /// /// The JSON representation for `StringValue` is JSON string. @@ -1236,6 +1866,96 @@ impl ::buffa::ViewReborrow for StringValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for StringValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::String(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.value.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for StringValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> StringValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; /// Wrapper message for `bytes`. /// /// The JSON representation for `BytesValue` is JSON string. @@ -1393,3 +2113,93 @@ impl ::buffa::ViewReborrow for BytesValueView<'static> { this } } +#[cfg(feature = "reflect")] +const _: () = { + impl<'a> ::buffa_descriptor::reflect::ReflectMessage for BytesValueView<'a> { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + super::super::__buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + super::super::__buffa::reflect::descriptor_pool() + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::Bytes(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this view's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.value.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, + ), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + let bytes = ::buffa::ViewEncode::encode_to_vec(self); + ::buffa_descriptor::reflect::DynamicMessage::decode( + ::buffa::alloc::sync::Arc::clone( + super::super::__buffa::reflect::descriptor_pool(), + ), + Self::__buffa_reflect_message_index(), + &bytes, + ) + .expect("view re-encodes to bytes decodable against its own descriptor") + } + } + impl<'a> ::buffa_descriptor::reflect::ReflectElement for BytesValueView<'a> { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl<'a> BytesValueView<'a> { + /// Memoized `MessageIndex` for this view's message type, resolved + /// once against the package's embedded descriptor pool. An inherent + /// associated fn (not a free fn) so sibling views in the same module + /// do not collide. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + super::super::__buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated view type is registered in the embedded descriptor pool", + ) + }) + } + } +}; diff --git a/buffa-types/src/generated/google.protobuf.wrappers.rs b/buffa-types/src/generated/google.protobuf.wrappers.rs index 19f0d8a..91585d9 100644 --- a/buffa-types/src/generated/google.protobuf.wrappers.rs +++ b/buffa-types/src/generated/google.protobuf.wrappers.rs @@ -32,6 +32,49 @@ impl ::buffa::DefaultInstance for DoubleValue { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for DoubleValue { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for DoubleValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "DoubleValue"; @@ -177,6 +220,49 @@ impl ::buffa::DefaultInstance for FloatValue { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for FloatValue { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for FloatValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "FloatValue"; @@ -322,6 +408,49 @@ impl ::buffa::DefaultInstance for Int64Value { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Int64Value { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Int64Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Int64Value"; @@ -467,6 +596,49 @@ impl ::buffa::DefaultInstance for UInt64Value { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for UInt64Value { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for UInt64Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "UInt64Value"; @@ -612,6 +784,49 @@ impl ::buffa::DefaultInstance for Int32Value { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for Int32Value { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for Int32Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Int32Value"; @@ -757,6 +972,49 @@ impl ::buffa::DefaultInstance for UInt32Value { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for UInt32Value { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for UInt32Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "UInt32Value"; @@ -902,6 +1160,49 @@ impl ::buffa::DefaultInstance for BoolValue { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for BoolValue { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for BoolValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "BoolValue"; @@ -1047,6 +1348,49 @@ impl ::buffa::DefaultInstance for StringValue { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for StringValue { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for StringValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "StringValue"; @@ -1195,6 +1539,49 @@ impl ::buffa::DefaultInstance for BytesValue { VALUE.get_or_init(|| ::buffa::alloc::boxed::Box::new(Self::default())) } } +#[cfg(feature = "reflect")] +impl ::buffa_descriptor::reflect::Reflectable for BytesValue { + /// Bridge-mode reflective handle: encodes `self` and decodes + /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) + /// against the package's embedded descriptor pool. + /// + /// # Performance + /// + /// One full encode/decode round-trip plus a heap allocation per + /// call. Hold onto the returned handle for repeated field reads + /// rather than calling `reflect()` per field. + /// + /// # Panics + /// + /// Panics if the embedded `FileDescriptorSet` is malformed or + /// `Self::FULL_NAME` is not registered. Both indicate codegen + /// emitted inconsistent output, not consumer misuse — except + /// when this type was re-exported from a different + /// `buffa-build` invocation, whose pool is a different + /// instance. Each `generate_reflection(true)` codegen run + /// embeds its own pool; do not mix `reflect()` calls across + /// independently-generated crates. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + let pool = __buffa::reflect::descriptor_pool(); + let idx = pool + .message_index(::FULL_NAME) + .unwrap_or_else(|| { + panic!( + "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", + < Self as ::buffa::MessageName > ::FULL_NAME, + ) + }); + ::buffa_descriptor::reflect::ReflectCow::Owned( + ::buffa::alloc::boxed::Box::new( + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(pool), + idx, + ), + ), + ) + } +} impl ::buffa::MessageName for BytesValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "BytesValue"; diff --git a/buffa-types/src/lib.rs b/buffa-types/src/lib.rs index 69b4f71..c2d256a 100644 --- a/buffa-types/src/lib.rs +++ b/buffa-types/src/lib.rs @@ -36,6 +36,19 @@ //! - `Any::pack` / `Any::unpack` helpers //! - `Value` constructors: [`Value::null`](google::protobuf::Value::null), `From`, `From`, `From`, etc. //! - Wrapper type `From`/`Into` impls +//! +//! # Cargo features +//! +//! - **`std`** (default) — standard-library integration (`SystemTime`/`Duration` +//! conversions, `std::error::Error`). Without it the crate is `no_std` + `alloc`. +//! - **`json`** — proto3 canonical JSON serde for the WKTs. +//! - **`arbitrary`** — `arbitrary::Arbitrary` derives for fuzzing. +//! - **`reflect`** — runtime reflection: the WKT view types implement +//! `buffa_descriptor::reflect::ReflectMessage`, so a message that has a WKT +//! field can reflect over it. This pulls a `buffa-descriptor` dependency and +//! requires `std` (the embedded descriptor pool uses `std::sync::OnceLock`). +//! If you reach for `&view as &dyn ReflectMessage` on a WKT view and the +//! compiler says `ReflectMessage` is not implemented, enable this feature. #![cfg_attr(not(feature = "std"), no_std)] #![deny(rustdoc::broken_intra_doc_links)] diff --git a/buffa-types/tests/wkt_reflect.rs b/buffa-types/tests/wkt_reflect.rs new file mode 100644 index 0000000..4767777 --- /dev/null +++ b/buffa-types/tests/wkt_reflect.rs @@ -0,0 +1,117 @@ +//! Vtable reflection over well-known-type views. +//! +//! Verifies the generated `impl ReflectMessage for View` (gated behind the +//! `reflect` feature). This is the prerequisite that lets consumer protos which +//! reference WKTs reflect over them — a WKT-typed message field reflects as +//! `ValueRef::Message` borrowing the WKT view. + +#![cfg(feature = "reflect")] + +use buffa::{Message, MessageView}; +use buffa_descriptor::reflect::{ReflectMessage, ValueRef}; +use buffa_types::google::protobuf as wkt; +// `__buffa::view` / `__buffa::oneof` are the codegen-emitted module paths for +// view types and oneof enums. The double-underscore marks them as generated +// internals, but they are the canonical way to name these types until a +// friendlier re-export exists — this is the same path `wkt_roundtrip.rs` uses. +use buffa_types::google::protobuf::__buffa::oneof::value::Kind as KindOneof; +use buffa_types::google::protobuf::__buffa::view as wkt_view; + +#[test] +fn timestamp_view_reflects_scalars() { + let ts = wkt::Timestamp { + seconds: 1_700_000_000, + nanos: 123_456_789, + ..Default::default() + }; + let bytes = ts.encode_to_vec(); + let view = wkt_view::TimestampView::decode_view(&bytes).expect("decode_view"); + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + // seconds = field 1 (int64), nanos = field 2 (int32). + assert!(matches!( + r.get(md.field(1).unwrap()), + ValueRef::I64(1_700_000_000) + )); + assert!(matches!( + r.get(md.field(2).unwrap()), + ValueRef::I32(123_456_789) + )); + assert!(r.has(md.field(1).unwrap())); +} + +#[test] +fn string_value_view_reflects_string() { + let w = wkt::StringValue { + value: "hello".into(), + ..Default::default() + }; + let bytes = w.encode_to_vec(); + let view = wkt_view::StringValueView::decode_view(&bytes).expect("decode_view"); + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + assert!(matches!( + r.get(md.field(1).unwrap()), + ValueRef::String("hello") + )); +} + +#[test] +fn struct_view_reflects_map_of_nested_value_oneof() { + // Struct.fields is map; Value.kind is a oneof. This + // exercises the two trickiest WKT reflection paths together: a map whose + // values are messages, and reflecting a nested message's oneof. + let mut s = wkt::Struct::default(); + s.fields.insert( + "pi".to_string(), + wkt::Value { + kind: Some(KindOneof::NumberValue(3.0)), + ..Default::default() + }, + ); + let bytes = s.encode_to_vec(); + let view = wkt_view::StructView::decode_view(&bytes).expect("decode_view"); + let r: &dyn ReflectMessage = &view; + let md = r.message_descriptor(); + + let fields_fd = md + .fields() + .iter() + .find(|f| f.name() == "fields") + .expect("fields map"); + let ValueRef::Map(m) = r.get(fields_fd) else { + panic!("expected Map") + }; + assert_eq!(m.len(), 1); + let Some(ValueRef::Message(value_cow)) = m.get_str("pi") else { + panic!("expected nested Value message") + }; + // Reflect the nested Value: number_value is oneof member field 2 (double). + let value_md = value_cow.message_descriptor(); + assert!(matches!( + value_cow.get(value_md.field(2).unwrap()), + ValueRef::F64(3.0) + )); +} + +#[test] +fn wkt_view_to_dynamic_snapshot() { + let d = wkt::Duration { + seconds: 5, + nanos: 250, + ..Default::default() + }; + let bytes = d.encode_to_vec(); + let view = wkt_view::DurationView::decode_view(&bytes).expect("decode_view"); + let r: &dyn ReflectMessage = &view; + let snapshot = r.to_dynamic(); + let md = snapshot.message_descriptor(); + assert!(matches!( + snapshot.get(md.field(1).unwrap()), + ValueRef::I64(5) + )); + assert!(matches!( + snapshot.get(md.field(2).unwrap()), + ValueRef::I32(250) + )); +} From 2e41fd2468a6bf37c431e9863f18f8c4dd50e6b8 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 18:19:47 +0000 Subject: [PATCH 04/12] conformance: add BUFFA_VIA_VTABLE run for view reflection MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add a sixth conformance run that exercises the generated `impl ReflectMessage for FooView`: decode a view, walk its vtable reflection surface (for_each_set/get) to rebuild a DynamicMessage, and serialize that to JSON. This reuses DynamicMessage's JSON serializer — which passes the corpus cleanly under BUFFA_VIA_REFLECT — so any failure isolates a bug in the vtable get/has surface rather than in JSON formatting. Binary and text output are skipped (the reflect rebuild drops unknown fields, which JSON omits anyway). The run passes 1246 binary->JSON conformance tests with zero failures across proto2/proto3/editions, so known_failures_view_vtable.txt is empty. Vtable reflection is enabled on the four view-bearing conformance protos and gated behind the conformance `reflect` feature (via the new buffa_build::Config::gate_reflect_on_crate_feature), so the no_std binary omits it. Also fix a latent needless-return in process_editions surfaced by clippy once the editions protos are present, and correct the stale conformance-run count in CONTRIBUTING (four runs -> six, including the previously undocumented via-reflect run). --- CONTRIBUTING.md | 22 ++++-- buffa-build/src/lib.rs | 19 +++++ buffa-codegen/src/lib.rs | 8 +- conformance/Cargo.lock | 81 ++++++++++++++++++++ conformance/Cargo.toml | 7 +- conformance/Dockerfile | 1 + conformance/build.rs | 17 +++++ conformance/known_failures_view_vtable.txt | 14 ++++ conformance/run-conformance.sh | 12 +++ conformance/src/main.rs | 89 +++++++++++++++++++++- 10 files changed, 256 insertions(+), 14 deletions(-) create mode 100644 conformance/known_failures_view_vtable.txt diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6a38b23..aafba97 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -47,23 +47,29 @@ task tools-image-local # builds for local platform only, ~5 min task conformance # now uses the locally-built image ``` -**Understanding the output**: The conformance runner executes four runs -(std, no_std, via-view, view-json), each producing two suites: +**Understanding the output**: The conformance runner executes six runs +(std, no_std, via-view, view-json, via-reflect, via-vtable), each producing two +suites: -1. Binary + JSON suite — expects thousands of successes (~5500 std, ~5500 no_std). The via-view run only handles binary→binary (~2800); the view-json run only handles binary→JSON (~1250). -2. Text format suite — 883 successes for std and no_std (the full suite); via-view and view-json show `0 successes, 883 skipped` (views have no `TextFormat` — textproto goes through the owned type via `to_owned_message()`) +1. Binary + JSON suite — expects thousands of successes (~5500 std, ~5500 no_std). The via-view run only handles binary→binary (~2800); the view-json, via-reflect, and via-vtable runs handle binary→JSON (and via-reflect also binary→binary). +2. Text format suite — 883 successes for std and no_std (the full suite); via-view, view-json, via-reflect, and via-vtable show `0 successes, 883 skipped` (those modes have no `TextFormat` path). -So a healthy run shows **8 `CONFORMANCE SUITE PASSED` lines**. +So a healthy run shows **12 `CONFORMANCE SUITE PASSED` lines**. -The Dockerfile builds **two binaries**: one with default features (std) and one with `--no-default-features` (no_std). The via-view run reuses the std binary with `BUFFA_VIA_VIEW=1` set, routing binary input through `decode_view → to_owned_message → encode` to verify owned/view decoder parity. The view-json run reuses the std binary with `BUFFA_VIEW_JSON=1` set, routing binary input through `decode_view → serde_json::to_string(&view)` to verify the generated view `Serialize` impls (and the hand-written WKT view `Serialize` impls in `buffa-types`) against the conformance JSON reference assertions, independently of the owned encoder. +The Dockerfile builds **two binaries**: one with default features (std) and one with `--no-default-features` (no_std). The std binary is reused for the view/reflect runs by setting an env var: -**Expected failures** are listed in `conformance/known_failures.txt` (std binary+JSON), `conformance/known_failures_nostd.txt` (no_std binary+JSON), `conformance/known_failures_view.txt` (via-view), `conformance/known_failures_view_json.txt` (view-json), and `conformance/known_failures_text.txt` (text format — shared between std and no_std; currently empty). The text list is passed via `--text_format_failure_list` since the runner validates each suite's list independently. When a previously-failing test starts passing, remove it from the relevant file; when a new test is expected to fail, add it. +- **via-view** (`BUFFA_VIA_VIEW=1`) — binary input through `decode_view → to_owned_message → encode`, verifying owned/view decoder parity. +- **view-json** (`BUFFA_VIEW_JSON=1`) — binary→JSON through `decode_view → serde_json::to_string(&view)`, verifying the generated view `Serialize` impls (and the hand-written WKT view `Serialize` impls in `buffa-types`). +- **via-reflect** (`BUFFA_VIA_REFLECT=1`) — binary/JSON I/O through `DynamicMessage`'s descriptor-driven codec and reflective serde, verifying the runtime reflection codec independently of any generated type. +- **via-vtable** (`BUFFA_VIA_VTABLE=1`) — binary→JSON through `decode_view → (walk the view's vtable `ReflectMessage` surface) → DynamicMessage → to_json`, verifying the generated `impl ReflectMessage for FooView`. It reuses `DynamicMessage`'s JSON serializer (which passes the corpus cleanly under via-reflect), so any failure isolates a bug in the vtable `get`/`has`/`for_each_set` surface. Requires the conformance crate's `reflect` feature, so it is absent from the no_std binary. + +**Expected failures** are listed in `conformance/known_failures.txt` (std binary+JSON), `conformance/known_failures_nostd.txt` (no_std binary+JSON), `conformance/known_failures_view.txt` (via-view), `conformance/known_failures_view_json.txt` (view-json), `conformance/known_failures_reflect.txt` (via-reflect), `conformance/known_failures_view_vtable.txt` (via-vtable), and `conformance/known_failures_text.txt` (text format — shared between std and no_std; currently empty). The text list is passed via `--text_format_failure_list` since the runner validates each suite's list independently. When a previously-failing test starts passing, remove it from the relevant file; when a new test is expected to fail, add it. **Capturing output**: To save per-run logs for analysis, mount a directory and set `CONFORMANCE_OUT`: ```bash docker run --rm -v /tmp/conf:/out -e CONFORMANCE_OUT=/out buffa-conformance -# logs: /tmp/conf/conformance-{std,nostd,view,view-json}.log +# logs: /tmp/conf/conformance-{std,nostd,view,view-json,reflect,vtable}.log ``` **Upgrading the protobuf version**: bump `TOOLS_IMAGE` in `Taskfile.yml` and `PROTOC_VERSION` in `.github/workflows/ci.yml`, then: diff --git a/buffa-build/src/lib.rs b/buffa-build/src/lib.rs index a8b1229..c04d234 100644 --- a/buffa-build/src/lib.rs +++ b/buffa-build/src/lib.rs @@ -223,6 +223,25 @@ impl Config { self } + /// Gate only the reflection impls behind a `reflect` crate feature, without + /// gating json/views/text (unlike + /// [`gate_impls_on_crate_features`](Self::gate_impls_on_crate_features), + /// which gates them together). + /// + /// For crates that ship views/text unconditionally but want the + /// `buffa-descriptor`-dependent (and `std`-requiring) reflection surface to + /// be opt-in. `buffa-types` is the motivating case. + /// + /// **Experimental and `#[doc(hidden)]`**, paired with + /// [`generate_reflection_vtable`](Self::generate_reflection_vtable) until the + /// public `ReflectMode` selector lands. + #[doc(hidden)] + #[must_use] + pub fn gate_reflect_on_crate_feature(mut self, enabled: bool) -> Self { + self.codegen_config.gate_reflect_on_crate_feature = enabled; + self + } + /// Enable or disable `with_*` builder-style setter methods for /// explicit-presence fields (default: true). /// diff --git a/buffa-codegen/src/lib.rs b/buffa-codegen/src/lib.rs index ef2da83..c6a1110 100644 --- a/buffa-codegen/src/lib.rs +++ b/buffa-codegen/src/lib.rs @@ -504,10 +504,10 @@ pub struct CodeGenConfig { /// When [`gate_impls_on_crate_features`](Self::gate_impls_on_crate_features) /// is already on, reflection is gated regardless and this flag is ignored. /// - /// This is a low-level knob for internal codegen tooling (it is set - /// directly by `gen_wkt_types`) and is not surfaced through `buffa-build`, - /// whose consumers ship a single crate and rarely need feature-gated - /// reflection. + /// A low-level knob for crates whose generated code is a public interface + /// (`buffa-types`, the conformance harness). Set directly by `gen_wkt_types` + /// and exposed through `buffa_build::Config::gate_reflect_on_crate_feature` + /// (currently `#[doc(hidden)]`, paired with the experimental vtable flag). /// /// Defaults to `false`. pub gate_reflect_on_crate_feature: bool, diff --git a/conformance/Cargo.lock b/conformance/Cargo.lock index 9b278d0..532b08f 100644 --- a/conformance/Cargo.lock +++ b/conformance/Cargo.lock @@ -20,16 +20,29 @@ version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" +[[package]] +name = "borsh" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a" +dependencies = [ + "bytes", + "cfg_aliases", +] + [[package]] name = "buffa" version = "0.6.0" dependencies = [ "base64", "bytes", + "compact_str", + "ecow", "hashbrown 0.15.5", "once_cell", "serde", "serde_json", + "smol_str", "thiserror", ] @@ -69,6 +82,7 @@ name = "buffa-types" version = "0.6.0" dependencies = [ "buffa", + "buffa-descriptor", "bytes", "serde", "serde_json", @@ -81,12 +95,42 @@ version = "1.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" +[[package]] +name = "castaway" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a" +dependencies = [ + "rustversion", +] + [[package]] name = "cfg-if" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + +[[package]] +name = "compact_str" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a" +dependencies = [ + "castaway", + "cfg-if", + "itoa", + "rustversion", + "ryu", + "serde", + "static_assertions", +] + [[package]] name = "conformance" version = "0.1.0" @@ -99,6 +143,15 @@ dependencies = [ "serde_json", ] +[[package]] +name = "ecow" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78e4f79b296fbaab6ce2e22d52cb4c7f010fe0ebe7a32e34fa25885fd797bd02" +dependencies = [ + "serde", +] + [[package]] name = "equivalent" version = "1.0.2" @@ -269,6 +322,18 @@ dependencies = [ "windows-sys", ] +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + [[package]] name = "semver" version = "1.0.27" @@ -318,6 +383,22 @@ dependencies = [ "zmij", ] +[[package]] +name = "smol_str" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9676b89cd56310a87b93dec47b11af744f34d5fc9f367b829474eec0a891350d" +dependencies = [ + "borsh", + "serde", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + [[package]] name = "syn" version = "2.0.115" diff --git a/conformance/Cargo.toml b/conformance/Cargo.toml index 204361c..14c8e3a 100644 --- a/conformance/Cargo.toml +++ b/conformance/Cargo.toml @@ -25,7 +25,12 @@ publish = false [features] default = ["buffa-std"] -buffa-std = ["buffa/std", "buffa-types/std"] +# `reflect` enables vtable-mode reflection on the generated view types and the +# WKT views (BUFFA_VIA_VTABLE run). It requires std, so it rides on `buffa-std` +# (the default) and is absent from the `--no-default-features` no_std binary — +# whose generated code therefore omits the reflect impls. +buffa-std = ["buffa/std", "buffa-types/std", "reflect"] +reflect = ["buffa-types/reflect"] [dependencies] buffa = { path = "../buffa", default-features = false, features = ["json", "text"] } diff --git a/conformance/Dockerfile b/conformance/Dockerfile index a6dce42..bac267f 100644 --- a/conformance/Dockerfile +++ b/conformance/Dockerfile @@ -56,6 +56,7 @@ COPY conformance/known_failures_view.txt /known_failures_view.txt COPY conformance/known_failures_view_json.txt /known_failures_view_json.txt COPY conformance/known_failures_text.txt /known_failures_text.txt COPY conformance/known_failures_reflect.txt /known_failures_reflect.txt +COPY conformance/known_failures_view_vtable.txt /known_failures_view_vtable.txt COPY conformance/run-conformance.sh /run-conformance.sh RUN chmod +x /run-conformance.sh diff --git a/conformance/build.rs b/conformance/build.rs index ca7369f..1530db0 100644 --- a/conformance/build.rs +++ b/conformance/build.rs @@ -21,12 +21,20 @@ fn main() { // WKT types come from buffa-types (with hand-written serde impls). // We only generate the test message types here. + // Vtable reflection is enabled on the view-bearing builds (proto3/proto2 and + // their editions variants) for the BUFFA_VIA_VTABLE run. It is gated behind + // the conformance `reflect` feature (via `gate_reflect_on_crate_feature`), + // so the no_std binary — built `--no-default-features` — omits it. + // TestAllTypesProto3 with serde + textproto enabled. buffa_build::Config::new() .files(&["protos/google/protobuf/test_messages_proto3.proto"]) .includes(&["protos/"]) .generate_json(true) .generate_text(true) + .generate_reflection(true) + .generate_reflection_vtable(true) + .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto3.proto"); @@ -37,6 +45,9 @@ fn main() { .generate_json(true) .generate_text(true) .allow_message_set(true) + .generate_reflection(true) + .generate_reflection_vtable(true) + .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto2.proto"); @@ -48,6 +59,9 @@ fn main() { .includes(&[&protos_dir]) .generate_json(true) .generate_text(true) + .generate_reflection(true) + .generate_reflection_vtable(true) + .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto3_editions.proto"); @@ -58,6 +72,9 @@ fn main() { .generate_json(true) .generate_text(true) .allow_message_set(true) + .generate_reflection(true) + .generate_reflection_vtable(true) + .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto2_editions.proto"); diff --git a/conformance/known_failures_view_vtable.txt b/conformance/known_failures_view_vtable.txt new file mode 100644 index 0000000..0e3f470 --- /dev/null +++ b/conformance/known_failures_view_vtable.txt @@ -0,0 +1,14 @@ +# Known conformance test failures for buffa (via-vtable mode). +# +# Tests listed here are expected to fail and will not cause the test run to +# report a failure. Each line is a test name (matched by the runner with +# --failure_list). Remove entries as failures are fixed. +# +# Via-vtable mode routes binary input + JSON output through +# decode_view → (walk the view's ReflectMessage surface) → DynamicMessage → +# to_json, exercising the generated `impl ReflectMessage for FooView`. Because +# it reuses DynamicMessage's JSON serializer (which passes the corpus cleanly in +# BUFFA_VIA_REFLECT mode), any failure here points at the vtable get/has surface +# producing a different value than a direct decode. +# +# (Currently empty.) diff --git a/conformance/run-conformance.sh b/conformance/run-conformance.sh index 651f70b..e9ce7c2 100755 --- a/conformance/run-conformance.sh +++ b/conformance/run-conformance.sh @@ -66,3 +66,15 @@ BUFFA_VIA_REFLECT=1 run_suite reflect \ --failure_list /known_failures_reflect.txt \ --maximum_edition 2024 \ /usr/local/bin/buffa-conformance + +# Via-vtable mode: serves binary input + JSON output by decoding a view, walking +# its vtable `ReflectMessage` surface (for_each_set/get) to rebuild a +# DynamicMessage, and serializing that to JSON. Exercises the generated +# `impl ReflectMessage for FooView` against the conformance JSON reference, +# independently of the view's own Serialize impl. Binary and text output are +# skipped (unknown-field preservation is out of scope for the reflect rebuild). +BUFFA_VIA_VTABLE=1 run_suite vtable \ + conformance_test_runner \ + --failure_list /known_failures_view_vtable.txt \ + --maximum_edition 2024 \ + /usr/local/bin/buffa-conformance diff --git a/conformance/src/main.rs b/conformance/src/main.rs index 086924d..7c9e151 100644 --- a/conformance/src/main.rs +++ b/conformance/src/main.rs @@ -256,6 +256,81 @@ fn process_via_reflect(req: &envelope::Request) -> envelope::Response { } } +// ── Via-vtable mode ──────────────────────────────────────────────────────── +// +// When `BUFFA_VIA_VTABLE=1`, binary input is decoded into a view, a +// `DynamicMessage` is rebuilt by walking the view's vtable `ReflectMessage` +// surface (`for_each_set` + `get`), and that `DynamicMessage` is serialized to +// JSON. This exercises the generated `impl ReflectMessage for FooView` against +// the conformance JSON reference, independently of the view's own `Serialize` +// impl (which `BUFFA_VIEW_JSON` covers). Only binary→JSON is exercised: +// `for_each_set` excludes unknown fields, which JSON output drops anyway, so +// there is no unknown-field divergence. Gated on the `reflect` feature (the +// view `ReflectMessage` impls only exist there), so the no_std binary omits it. + +#[cfg(all(not(no_protos), feature = "reflect"))] +fn via_vtable() -> bool { + static FLAG: std::sync::OnceLock = std::sync::OnceLock::new(); + *FLAG.get_or_init(|| std::env::var("BUFFA_VIA_VTABLE").as_deref() == Ok("1")) +} + +/// Rebuild a `DynamicMessage` from any `ReflectMessage` by walking its set +/// fields through the vtable surface. Nested messages and containers go through +/// [`ValueRef::to_owned`]; the top-level `for_each_set`/`get` is the path under +/// test. +#[cfg(all(not(no_protos), feature = "reflect"))] +fn reflect_to_dynamic( + m: &dyn buffa_descriptor::reflect::ReflectMessage, +) -> buffa_descriptor::reflect::DynamicMessage { + use buffa_descriptor::reflect::ReflectMessageMut; + let mut out = buffa_descriptor::reflect::DynamicMessage::new_by_name( + std::sync::Arc::clone(m.pool()), + m.message_descriptor().full_name(), + ) + .expect("reflected message type is registered in its own descriptor pool"); + m.for_each_set(&mut |fd, vr| out.set(fd, vr.to_owned())); + out +} + +/// Binary→JSON via `decode_view → reflect_to_dynamic → DynamicMessage::to_json`. +#[cfg(all(not(no_protos), feature = "reflect"))] +fn vtable_json<'a, V>(bytes: &'a [u8]) -> envelope::Response +where + V: buffa::MessageView<'a> + buffa_descriptor::reflect::ReflectMessage, +{ + use envelope::Response; + let view = match V::decode_view(bytes) { + Ok(v) => v, + Err(e) => return Response::ParseError(format!("{e}")), + }; + match reflect_to_dynamic(&view).to_json() { + Ok(s) => Response::JsonPayload(s), + Err(e) => Response::SerializeError(format!("{e}")), + } +} + +/// Dispatch the vtable JSON path by message type. +#[cfg(all(not(no_protos), feature = "reflect"))] +fn process_via_vtable(req: &envelope::Request) -> envelope::Response { + use envelope::{Payload, Response}; + let Some(Payload::Protobuf(b)) = &req.payload else { + return Response::RuntimeError("process_via_vtable called without protobuf payload".into()); + }; + match req.message_type.as_str() { + MSG_PROTO3 => vtable_json::>(b), + MSG_PROTO2 => vtable_json::>(b), + #[cfg(has_editions_protos)] + MSG_EDITIONS_PROTO3 => { + vtable_json::>(b) + } + #[cfg(has_editions_protos)] + MSG_EDITIONS_PROTO2 => { + vtable_json::>(b) + } + other => Response::Skipped(format!("message type '{other}' not in vtable dispatch")), + } +} + /// Decode `bytes` as a view and serialize that view directly to JSON. #[cfg(not(no_protos))] fn encode_view_json<'a, V>(bytes: &'a [u8]) -> envelope::Response @@ -401,6 +476,18 @@ fn process(req: &envelope::Request) -> envelope::Response { }; } + // Via-vtable mode: binary→JSON through the view's `ReflectMessage` surface. + // Only present when the `reflect` feature is on (the std binary). + #[cfg(feature = "reflect")] + if via_vtable() { + return match &req.payload { + Some(Payload::Protobuf(_)) if req.requested_output_format == WireFormat::Json => { + process_via_vtable(req) + } + _ => Response::Skipped("vtable mode: only binary→JSON exercised".into()), + }; + } + let ignore_unknown = req.test_category == envelope::TestCategory::JsonIgnoreUnknownParsing; let pu = req.print_unknown_fields; @@ -544,7 +631,7 @@ fn process_editions( ) -> envelope::Response { #[cfg(has_editions_protos)] { - return process_editions_inner(req, ignore_unknown); + process_editions_inner(req, ignore_unknown) } #[cfg(not(has_editions_protos))] envelope::Response::Skipped(format!( From 4f93e5f082dc6e41748034b4b9e62aeb8ff9d94d Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 20:39:40 +0000 Subject: [PATCH 05/12] benchmarks: add vtable view reflection cases to the reflect bench MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Extend the reflection benchmark with the zero-copy view path so the vtable ReflectMessage work can be measured against the alternatives: - decode/view — decode_view alone (no reflection), the zero-copy floor. - reflect/{vtable,bridge,dynamic}_read_{one,all} — from wire bytes, obtain a reflective handle and read one field / all set fields, comparing the view vtable path, the bridge round-trip, and pure DynamicMessage reflection. Enables generate_reflection_vtable on the bench types so the view types implement ReflectMessage. Measurements: vtable view reflection runs ~6-10x faster than the bridge round-trip and ~4x faster than pure DynamicMessage reflection, because it is dominated by decode_view, which is itself cheaper than owned decode (borrowed strings/bytes, no per-field allocation). --- benchmarks/buffa/Cargo.lock | 74 ++++++++++++ benchmarks/buffa/benches/reflect.rs | 171 +++++++++++++++++++++++++--- benchmarks/buffa/build.rs | 1 + 3 files changed, 230 insertions(+), 16 deletions(-) diff --git a/benchmarks/buffa/Cargo.lock b/benchmarks/buffa/Cargo.lock index 67fa53e..c826af9 100644 --- a/benchmarks/buffa/Cargo.lock +++ b/benchmarks/buffa/Cargo.lock @@ -59,16 +59,29 @@ version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" +[[package]] +name = "borsh" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a" +dependencies = [ + "bytes", + "cfg_aliases", +] + [[package]] name = "buffa" version = "0.6.0" dependencies = [ "base64", "bytes", + "compact_str", + "ecow", "hashbrown 0.15.5", "once_cell", "serde", "serde_json", + "smol_str", "thiserror", ] @@ -121,12 +134,27 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" +[[package]] +name = "castaway" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a" +dependencies = [ + "rustversion", +] + [[package]] name = "cfg-if" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + [[package]] name = "ciborium" version = "0.2.2" @@ -179,6 +207,21 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831" +[[package]] +name = "compact_str" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a" +dependencies = [ + "castaway", + "cfg-if", + "itoa", + "rustversion", + "ryu", + "serde", + "static_assertions", +] + [[package]] name = "criterion" version = "0.5.1" @@ -246,6 +289,15 @@ version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" +[[package]] +name = "ecow" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78e4f79b296fbaab6ce2e22d52cb4c7f010fe0ebe7a32e34fa25885fd797bd02" +dependencies = [ + "serde", +] + [[package]] name = "either" version = "1.15.0" @@ -567,6 +619,12 @@ version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + [[package]] name = "same-file" version = "1.0.6" @@ -625,6 +683,22 @@ dependencies = [ "zmij", ] +[[package]] +name = "smol_str" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9676b89cd56310a87b93dec47b11af744f34d5fc9f367b829474eec0a891350d" +dependencies = [ + "borsh", + "serde", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + [[package]] name = "syn" version = "2.0.116" diff --git a/benchmarks/buffa/benches/reflect.rs b/benchmarks/buffa/benches/reflect.rs index b39763a..4d4811f 100644 --- a/benchmarks/buffa/benches/reflect.rs +++ b/benchmarks/buffa/benches/reflect.rs @@ -6,30 +6,35 @@ //! does the genericity cost?" so consumers (CEL evaluators, transcoding //! gateways, generic interceptors) can budget for it. //! -//! Three things are measured per dataset: +//! Measured per dataset: //! -//! 1. **Generated decode** — `T::decode_from_slice(bytes)`. The baseline. -//! 2. **Reflective decode** — `DynamicMessage::decode(pool, idx, bytes)`. -//! Same wire bytes, descriptor-driven field dispatch instead of -//! generated match arms, `BTreeMap` storage instead of -//! struct fields. -//! 3. **Generated encode** vs. **Reflective encode** — `t.encode_to_vec()` -//! on each. -//! 4. **Bridge round-trip** — `t.reflect()`. The cost a generic -//! interceptor pays per message: one full encode + decode + boxed -//! `DynamicMessage`. This is the headline number for the connect-rust -//! interceptor use case and the codegen-emitted `Reflectable` impl. +//! 1. **Decode** — `decode/generated` (`T::decode_from_slice`), +//! `decode/reflect` (`DynamicMessage::decode`, descriptor-driven), and +//! `decode/view` (`decode_view`, zero-copy — strings/bytes borrow from the +//! input, so this is the floor, below even generated decode). +//! 2. **Encode** — `encode/generated` vs. `encode/reflect`. +//! 3. **Bridge round-trip** — `t.reflect()`: one full encode + decode + boxed +//! `DynamicMessage`, the cost of the codegen-emitted `Reflectable` impl. +//! 4. **From wire bytes to reflective field reads** — the interceptor / +//! field-mask workload, in `read_one` and `read_all` variants across three +//! handle strategies: `vtable_*` (`decode_view` + borrow as +//! `&dyn ReflectMessage`), `bridge_*` (`T::decode` then `.reflect()`), and +//! `dynamic_*` (`DynamicMessage::decode`). Vtable reflection is dominated by +//! the cheap zero-copy `decode_view`, so it lands well below both the bridge +//! round-trip and pure `DynamicMessage` reflection. use std::sync::Arc; -use buffa::Message; -use buffa_descriptor::reflect::{DynamicMessage, Reflectable}; +use buffa::{Message, MessageView}; +use buffa_descriptor::reflect::{DynamicMessage, ReflectMessage, Reflectable}; use buffa_descriptor::{DescriptorPool, MessageIndex}; use criterion::{criterion_group, criterion_main, Criterion, Throughput}; -use bench_buffa::bench::{AnalyticsEvent, ApiResponse, LogRecord}; +use bench_buffa::bench::{ + AnalyticsEvent, AnalyticsEventView, ApiResponse, ApiResponseView, LogRecord, LogRecordView, +}; use bench_buffa::benchmarks::BenchmarkDataset; -use bench_buffa::proto3::GoogleMessage1; +use bench_buffa::proto3::{GoogleMessage1, GoogleMessage1View}; fn load_dataset(data: &[u8]) -> BenchmarkDataset { BenchmarkDataset::decode_from_slice(data).expect("failed to decode dataset") @@ -39,12 +44,62 @@ fn total_payload_bytes(dataset: &BenchmarkDataset) -> u64 { dataset.payload.iter().map(|p| p.len() as u64).sum() } +/// Read the first declared field through a reflective handle (the field-mask +/// "extract one field" shape). +fn read_one(m: &dyn ReflectMessage) { + if let Some(fd) = m.message_descriptor().fields().first() { + criterion::black_box(m.get(fd)); + } +} + +/// Visit every set field through a reflective handle (the "scan the whole +/// message" shape — a generic redactor or a full transcode). +fn read_all(m: &dyn ReflectMessage) { + m.for_each_set(&mut |_fd, v| { + criterion::black_box(v); + }); +} + +/// Zero-copy decode floor: `decode_view(bytes)` and discard, no reflection. +/// Isolates the view-decode cost that the vtable reflection paths build on. +fn vtable_decode_only<'a, V>(payload: &'a [u8]) +where + V: MessageView<'a>, +{ + criterion::black_box(V::decode_view(payload).expect("decode_view")); +} + +/// Vtable path: `decode_view(bytes)` then read the first field. +fn vtable_read_one<'a, V>(payload: &'a [u8]) +where + V: MessageView<'a> + ReflectMessage, +{ + let view = V::decode_view(payload).expect("decode_view"); + read_one(&view); +} + +/// Vtable path: `decode_view(bytes)` then visit every set field. +fn vtable_read_all<'a, V>(payload: &'a [u8]) +where + V: MessageView<'a> + ReflectMessage, +{ + let view = V::decode_view(payload).expect("decode_view"); + read_all(&view); +} + +// The view-path closures (decode, read-one, read-all) are passed individually +// because each call site monomorphizes them over a different concrete view +// type; bundling them would not reduce the real coupling. +#[allow(clippy::too_many_arguments)] fn bench_message( c: &mut Criterion, name: &str, full_name: &str, pool: &'static Arc, dataset_bytes: &[u8], + vt_decode: impl Fn(&[u8]), + vt_read_one: impl Fn(&[u8]), + vt_read_all: impl Fn(&[u8]), ) where M: Message + Default + Reflectable, { @@ -91,6 +146,17 @@ fn bench_message( }); }); + // Zero-copy view decode (no reflection) — the floor the vtable reflection + // paths build on. Strings/bytes borrow from the input instead of being + // copied into owned `String`/`Vec`, so this undercuts even `decode/generated`. + group.bench_function("decode/view", |b| { + b.iter(|| { + for payload in &dataset.payload { + vt_decode(payload); + } + }); + }); + group.bench_function("encode/generated", |b| { b.iter(|| { for m in &typed { @@ -118,6 +184,67 @@ fn bench_message( }); }); + // ── From wire bytes to reflective field reads ───────────────────────── + // + // The interceptor / field-mask workload: given a wire payload, obtain a + // reflective handle and read field(s). Three handle strategies, each in a + // "read one field" and "read all set fields" variant: + // + // vtable — decode_view(bytes), borrow as &dyn ReflectMessage + // bridge — M::decode(bytes) then .reflect() (encode + decode + Box) + // dynamic — DynamicMessage::decode(bytes) (pure reflection, no typed step) + + group.bench_function("reflect/vtable_read_one", |b| { + b.iter(|| { + for payload in &dataset.payload { + vt_read_one(payload); + } + }); + }); + group.bench_function("reflect/vtable_read_all", |b| { + b.iter(|| { + for payload in &dataset.payload { + vt_read_all(payload); + } + }); + }); + + group.bench_function("reflect/bridge_read_one", |b| { + b.iter(|| { + for payload in &dataset.payload { + let m = M::decode_from_slice(payload).expect("decode"); + read_one(&*m.reflect()); + } + }); + }); + group.bench_function("reflect/bridge_read_all", |b| { + b.iter(|| { + for payload in &dataset.payload { + let m = M::decode_from_slice(payload).expect("decode"); + read_all(&*m.reflect()); + } + }); + }); + + group.bench_function("reflect/dynamic_read_one", |b| { + b.iter(|| { + for payload in &dataset.payload { + let dm = + DynamicMessage::decode(Arc::clone(p), idx, payload).expect("reflect decode"); + read_one(&dm); + } + }); + }); + group.bench_function("reflect/dynamic_read_all", |b| { + b.iter(|| { + for payload in &dataset.payload { + let dm = + DynamicMessage::decode(Arc::clone(p), idx, payload).expect("reflect decode"); + read_all(&dm); + } + }); + }); + group.finish(); } @@ -128,6 +255,9 @@ fn benchmark_api_response(c: &mut Criterion) { "bench.ApiResponse", bench_buffa::bench::__buffa::reflect::descriptor_pool(), include_bytes!("../../datasets/api_response.pb"), + |p| vtable_decode_only::>(p), + |p| vtable_read_one::>(p), + |p| vtable_read_all::>(p), ); } @@ -138,6 +268,9 @@ fn benchmark_log_record(c: &mut Criterion) { "bench.LogRecord", bench_buffa::bench::__buffa::reflect::descriptor_pool(), include_bytes!("../../datasets/log_record.pb"), + |p| vtable_decode_only::>(p), + |p| vtable_read_one::>(p), + |p| vtable_read_all::>(p), ); } @@ -148,6 +281,9 @@ fn benchmark_analytics_event(c: &mut Criterion) { "bench.AnalyticsEvent", bench_buffa::bench::__buffa::reflect::descriptor_pool(), include_bytes!("../../datasets/analytics_event.pb"), + |p| vtable_decode_only::>(p), + |p| vtable_read_one::>(p), + |p| vtable_read_all::>(p), ); } @@ -158,6 +294,9 @@ fn benchmark_google_message1(c: &mut Criterion) { "benchmarks.proto3.GoogleMessage1", bench_buffa::proto3::__buffa::reflect::descriptor_pool(), include_bytes!("../../datasets/google_message1_proto3.pb"), + |p| vtable_decode_only::>(p), + |p| vtable_read_one::>(p), + |p| vtable_read_all::>(p), ); } diff --git a/benchmarks/buffa/build.rs b/benchmarks/buffa/build.rs index b8279dd..2592be9 100644 --- a/benchmarks/buffa/build.rs +++ b/benchmarks/buffa/build.rs @@ -8,6 +8,7 @@ fn main() { .includes(&["../proto/"]) .generate_json(true) .generate_reflection(true) + .generate_reflection_vtable(true) .compile() .expect("failed to compile benchmark protos"); } From 15877fced1bf8d35014615ce49672a6ea2369db7 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 21:28:15 +0000 Subject: [PATCH 06/12] descriptor: reflect impls for owned containers (owned-vtable groundwork) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add ReflectElement for the owned element types (String, Vec, Bytes) and Value, ReflectMapKey for String, and generic ReflectList for Vec plus ReflectMap for std::collections::HashMap (std-gated — vtable reflection needs std). This lets owned-message vtable reflection return ValueRef::List(&self.field) / ValueRef::Map(&self.field) over owned Vec/HashMap storage, mirroring the view-container impls. The generic Vec impl subsumes the bridge DynamicMessage's Vec storage via ReflectElement for Value, so the bespoke ReflectList for Vec is removed — a single list impl now covers both. MapValue keeps its own ReflectMap impl (distinct sorted-vec type). Bridge conformance/e2e unaffected. --- buffa-descriptor/src/reflect/value.rs | 19 +-- buffa-descriptor/src/reflect/view.rs | 163 ++++++++++++++++++++++++-- 2 files changed, 156 insertions(+), 26 deletions(-) diff --git a/buffa-descriptor/src/reflect/value.rs b/buffa-descriptor/src/reflect/value.rs index 69c8ecf..70680f0 100644 --- a/buffa-descriptor/src/reflect/value.rs +++ b/buffa-descriptor/src/reflect/value.rs @@ -272,22 +272,9 @@ impl MapKey { } } -// `Vec` rather than `[Value]` so the `&Vec → &dyn ReflectList` -// unsizing coercion is valid — Rust requires the source type of an unsizing -// coercion to be `Sized`, and `[Value]` isn't. -impl ReflectList for Vec { - fn len(&self) -> usize { - Self::len(self) - } - fn get(&self, idx: usize) -> Option> { - self.as_slice().get(idx).map(Value::as_ref) - } - fn for_each(&self, f: &mut dyn FnMut(ValueRef<'_>)) { - for v in self.as_slice() { - f(v.as_ref()); - } - } -} +// `Vec` reflects through the generic `impl +// ReflectList for Vec` in `view.rs` (with `impl ReflectElement for Value`), +// so there is no bespoke `ReflectList for Vec` here. impl ReflectMap for MapValue { fn len(&self) -> usize { diff --git a/buffa-descriptor/src/reflect/view.rs b/buffa-descriptor/src/reflect/view.rs index 2855b7b..a8b475a 100644 --- a/buffa-descriptor/src/reflect/view.rs +++ b/buffa-descriptor/src/reflect/view.rs @@ -1,14 +1,20 @@ -//! Reflective container access over zero-copy [view types](buffa::view). +//! Reflective container access for vtable-mode reflection. //! //! This module bridges the reflection value model ([`ValueRef`], -//! [`ReflectList`], [`ReflectMap`]) to the view containers -//! [`RepeatedView`](buffa::RepeatedView) and [`MapView`](buffa::MapView), so a -//! vtable-mode `impl ReflectMessage for FooView<'a>` can return -//! `ValueRef::List(&self.tags)` / `ValueRef::Map(&self.labels)` without -//! materializing a `Vec` or `MapValue`. The bridge path -//! ([`DynamicMessage`](super::DynamicMessage)) implements the same -//! [`ReflectList`] / [`ReflectMap`] traits for `Vec` / `MapValue` (see -//! `value.rs`); these impls are the vtable counterpart. +//! [`ReflectList`], [`ReflectMap`]) to the concrete containers generated code +//! holds, so a vtable-mode `impl ReflectMessage` can return +//! `ValueRef::List(&self.tags)` / `ValueRef::Map(&self.labels)` directly: +//! +//! - **View types** — [`RepeatedView`](buffa::RepeatedView) / +//! [`MapView`](buffa::MapView), borrowing `&str` / `&[u8]` elements. +//! - **Owned types** — `Vec` / `std::collections::HashMap`, with owned +//! `String` / `Vec` / [`Bytes`](buffa::bytes::Bytes) elements. +//! +//! The generic `ReflectList for Vec` impl also subsumes the bridge +//! [`DynamicMessage`](super::DynamicMessage)'s `Vec` storage (via +//! `impl ReflectElement for Value`), so there is a single list impl rather than +//! a bespoke one per backing type. [`MapValue`](super::MapValue) keeps its own +//! [`ReflectMap`] impl in `value.rs` (it is a distinct sorted-vec type). //! //! ## Why a per-element helper trait, and why it is not a blanket //! @@ -27,9 +33,13 @@ //! //! See `docs/investigations/reflection-vtable.md` §3 for the full rationale. +use alloc::string::String; +use alloc::vec::Vec; + +use buffa::bytes::Bytes; use buffa::{EnumValue, Enumeration, MapView, RepeatedView}; -use super::value::{MapKey, MapKeyRef, ReflectList, ReflectMap, ValueRef}; +use super::value::{MapKey, MapKeyRef, ReflectList, ReflectMap, Value, ValueRef}; /// Conversion of a single repeated-field element (or map value) to a borrowed /// [`ValueRef`]. @@ -111,6 +121,38 @@ impl ReflectElement for EnumValue { } } +// ── Owned element impls ───────────────────────────────────────────────────── +// +// Owned messages hold `String` / `Vec` / `Bytes` (rather than the view +// path's borrowed `&str` / `&[u8]`) and store repeated/map fields as `Vec` / +// `HashMap`. These impls let the generic container impls below cover owned +// collections too. `Value` is included so the bridge `DynamicMessage`'s +// `Vec` rides the same generic `ReflectList` impl. + +impl ReflectElement for String { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::String(self) + } +} + +impl ReflectElement for Vec { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::Bytes(self) + } +} + +impl ReflectElement for Bytes { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::Bytes(self) + } +} + +impl ReflectElement for Value { + fn as_value_ref(&self) -> ValueRef<'_> { + self.as_ref() + } +} + // ── Map key impls (spec-valid key set) ────────────────────────────────────── macro_rules! impl_scalar_key { @@ -137,6 +179,12 @@ impl ReflectMapKey for &str { } } +impl ReflectMapKey for String { + fn as_map_key_ref(&self) -> MapKeyRef<'_> { + MapKeyRef::String(self) + } +} + impl ReflectMapKey for &[u8] { fn as_map_key_ref(&self) -> MapKeyRef<'_> { // Reached only for a `string` map key with editions @@ -211,6 +259,57 @@ impl ReflectMap for MapView<'_, K, V> { } } +// ── Owned containers ──────────────────────────────────────────────────────── + +/// Owned repeated storage (`Vec`). Also subsumes the bridge +/// `DynamicMessage`'s `Vec` (via `impl ReflectElement for Value`), so +/// there is no separate `ReflectList for Vec`. +impl ReflectList for Vec { + fn len(&self) -> usize { + self.as_slice().len() + } + + fn get(&self, idx: usize) -> Option> { + self.as_slice().get(idx).map(ReflectElement::as_value_ref) + } + + fn for_each(&self, f: &mut dyn FnMut(ValueRef<'_>)) { + for elem in self { + f(elem.as_value_ref()); + } + } +} + +/// Owned map storage. Keys are unique by construction (no dedup needed). Vtable +/// reflection requires `std` (the descriptor pool uses `OnceLock`), so the +/// owned-map impl is `std`-gated and targets `std::collections::HashMap` — the +/// concrete type generated code uses for `map` fields under `std`. +#[cfg(feature = "std")] +impl ReflectMap for std::collections::HashMap { + fn len(&self) -> usize { + Self::len(self) + } + + fn get(&self, key: &MapKey) -> Option> { + let want = key.as_ref(); + self.iter() + .find(|(k, _)| k.as_map_key_ref() == want) + .map(|(_, v)| v.as_value_ref()) + } + + fn get_str(&self, key: &str) -> Option> { + self.iter() + .find(|(k, _)| matches!(k.as_map_key_ref(), MapKeyRef::String(s) if s == key)) + .map(|(_, v)| v.as_value_ref()) + } + + fn for_each(&self, f: &mut dyn FnMut(MapKeyRef<'_>, ValueRef<'_>)) { + for (k, v) in self { + f(k.as_map_key_ref(), v.as_value_ref()); + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -346,4 +445,48 @@ mod tests { }); assert_eq!(keys, vec!["apples".to_string()]); } + + // ── Owned containers (owned-message vtable path) ───────────────────────── + + #[test] + fn owned_vec_of_string() { + let v: Vec = vec!["a".to_string(), "b".to_string()]; + let list: &dyn ReflectList = &v; + assert_eq!(list.len(), 2); + assert!(matches!(list.get(0), Some(ValueRef::String("a")))); + assert!(matches!(list.get(1), Some(ValueRef::String("b")))); + } + + #[test] + fn owned_vec_of_value_still_reflects() { + // The bridge `DynamicMessage` repeated storage rides the generic impl + // via `impl ReflectElement for Value`. + let v: Vec = vec![Value::I32(7), Value::I32(11)]; + let list: &dyn ReflectList = &v; + assert_eq!(list.len(), 2); + assert!(matches!(list.get(1), Some(ValueRef::I32(11)))); + } + + #[cfg(feature = "std")] + #[test] + fn owned_hashmap() { + let mut m: std::collections::HashMap = std::collections::HashMap::new(); + m.insert("apples".to_string(), 3); + m.insert("oranges".to_string(), 7); + let map: &dyn ReflectMap = &m; + assert_eq!(map.len(), 2); + assert!(matches!(map.get_str("apples"), Some(ValueRef::I32(3)))); + assert!(matches!( + map.get(&MapKey::String("oranges".into())), + Some(ValueRef::I32(7)) + )); + assert!(map.get_str("durian").is_none()); + let mut total = 0; + map.for_each(&mut |_k, v| { + if let ValueRef::I32(n) = v { + total += n; + } + }); + assert_eq!(total, 10); + } } From 25d47f77064a44fb5055a9cada2147d79766ed2c Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 21:49:55 +0000 Subject: [PATCH 07/12] codegen: owned-message vtable reflection + reflect() borrow MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Emit `impl ReflectMessage` / `impl ReflectElement` on the owned message struct in vtable mode (parallel to the view impls), reading owned fields directly — String/Vec/Bytes, MessageField, Vec/HashMap containers, owned oneof enums, closed-enum has(). The owned Reflectable::reflect() body then becomes ReflectCow::Borrowed(self): reflecting an in-memory message costs no encode/decode round-trip (the interceptor use case), while bridge mode keeps the round-trip. The reflective handle still borrows self, so the call site is unchanged between modes. owned ReflectMessage overrides unknown_fields() to return the message's preserved unknowns (gated on preserve_unknown_fields), matching the bridge path — without it a recursive reflective walk would silently drop them. Tests: reflectable.rs now compares owned-vtable vs bridge reflection field by field (scalars, string, bytes, enum, nested message, repeated, map, optional, oneof) and asserts reflect() borrows; reflect_vtable.rs adds an OwnedView entry-point test. WKT views/owned types regenerated with the owned impls (reflect feature now pulls buffa-descriptor/std for the HashMap ReflectMap). Renamed reflect/view.rs -> reflect/containers.rs (it now holds owned containers too) and refreshed the now-inaccurate "vtable is deferred" docs. --- benchmarks/buffa/benches/reflect.rs | 41 +- buffa-codegen/src/impl_message.rs | 53 +- buffa-codegen/src/lib.rs | 22 +- buffa-codegen/src/reflect.rs | 53 +- buffa-codegen/src/reflect_owned.rs | 355 +++++ buffa-codegen/src/reflect_view.rs | 4 +- .../src/reflect/{view.rs => containers.rs} | 30 +- buffa-descriptor/src/reflect/message.rs | 53 +- buffa-descriptor/src/reflect/mod.rs | 4 +- buffa-test/tests/reflect_vtable.rs | 19 +- buffa-test/tests/reflectable.rs | 90 ++ buffa-types/Cargo.toml | 2 +- .../src/generated/google.protobuf.any.rs | 134 +- .../src/generated/google.protobuf.duration.rs | 134 +- .../src/generated/google.protobuf.empty.rs | 130 +- .../generated/google.protobuf.field_mask.rs | 132 +- .../src/generated/google.protobuf.mod.rs | 5 +- .../src/generated/google.protobuf.struct.rs | 500 +++++-- .../generated/google.protobuf.timestamp.rs | 134 +- .../src/generated/google.protobuf.wrappers.rs | 1188 ++++++++++++----- 20 files changed, 2315 insertions(+), 768 deletions(-) create mode 100644 buffa-codegen/src/reflect_owned.rs rename buffa-descriptor/src/reflect/{view.rs => containers.rs} (93%) diff --git a/benchmarks/buffa/benches/reflect.rs b/benchmarks/buffa/benches/reflect.rs index 4d4811f..87809be 100644 --- a/benchmarks/buffa/benches/reflect.rs +++ b/benchmarks/buffa/benches/reflect.rs @@ -13,20 +13,24 @@ //! `decode/view` (`decode_view`, zero-copy — strings/bytes borrow from the //! input, so this is the floor, below even generated decode). //! 2. **Encode** — `encode/generated` vs. `encode/reflect`. -//! 3. **Bridge round-trip** — `t.reflect()`: one full encode + decode + boxed -//! `DynamicMessage`, the cost of the codegen-emitted `Reflectable` impl. +//! 3. **Owned-message reflection** — `bridge_round_trip` +//! (`DynamicMessage::from_message`: encode + decode + box, the bridge cost) +//! vs. `owned_vtable_read_all` (borrow the owned message via `ReflectMessage` +//! and scan it — no round-trip). This is the win from vtable mode making +//! `Reflectable::reflect()` borrow `self`. //! 4. **From wire bytes to reflective field reads** — the interceptor / //! field-mask workload, in `read_one` and `read_all` variants across three //! handle strategies: `vtable_*` (`decode_view` + borrow as -//! `&dyn ReflectMessage`), `bridge_*` (`T::decode` then `.reflect()`), and -//! `dynamic_*` (`DynamicMessage::decode`). Vtable reflection is dominated by -//! the cheap zero-copy `decode_view`, so it lands well below both the bridge -//! round-trip and pure `DynamicMessage` reflection. +//! `&dyn ReflectMessage`), `bridge_*` (`T::decode` then +//! `DynamicMessage::from_message`), and `dynamic_*` (`DynamicMessage::decode`). +//! Vtable reflection is dominated by the cheap zero-copy `decode_view`, so it +//! lands well below both the bridge round-trip and pure `DynamicMessage` +//! reflection. use std::sync::Arc; use buffa::{Message, MessageView}; -use buffa_descriptor::reflect::{DynamicMessage, ReflectMessage, Reflectable}; +use buffa_descriptor::reflect::{DynamicMessage, ReflectMessage}; use buffa_descriptor::{DescriptorPool, MessageIndex}; use criterion::{criterion_group, criterion_main, Criterion, Throughput}; @@ -101,7 +105,7 @@ fn bench_message( vt_read_one: impl Fn(&[u8]), vt_read_all: impl Fn(&[u8]), ) where - M: Message + Default + Reflectable, + M: Message + Default + ReflectMessage, { let dataset = load_dataset(dataset_bytes); let bytes = total_payload_bytes(&dataset); @@ -179,7 +183,18 @@ fn bench_message( group.bench_function("reflect/bridge_round_trip", |b| { b.iter(|| { for m in &typed { - criterion::black_box(m.reflect()); + criterion::black_box(DynamicMessage::from_message(m, Arc::clone(p), idx)); + } + }); + }); + + // Owned-message reflection (a server reflecting its in-memory response): + // vtable mode borrows the owned message directly via `ReflectMessage`, so + // there is no round-trip — contrast with `bridge_round_trip` above. + group.bench_function("reflect/owned_vtable_read_all", |b| { + b.iter(|| { + for m in &typed { + read_all(m); } }); }); @@ -191,7 +206,7 @@ fn bench_message( // "read one field" and "read all set fields" variant: // // vtable — decode_view(bytes), borrow as &dyn ReflectMessage - // bridge — M::decode(bytes) then .reflect() (encode + decode + Box) + // bridge — M::decode(bytes) then DynamicMessage::from_message (round-trip) // dynamic — DynamicMessage::decode(bytes) (pure reflection, no typed step) group.bench_function("reflect/vtable_read_one", |b| { @@ -213,7 +228,8 @@ fn bench_message( b.iter(|| { for payload in &dataset.payload { let m = M::decode_from_slice(payload).expect("decode"); - read_one(&*m.reflect()); + let dm = DynamicMessage::from_message(&m, Arc::clone(p), idx); + read_one(&dm); } }); }); @@ -221,7 +237,8 @@ fn bench_message( b.iter(|| { for payload in &dataset.payload { let m = M::decode_from_slice(payload).expect("decode"); - read_all(&*m.reflect()); + let dm = DynamicMessage::from_message(&m, Arc::clone(p), idx); + read_all(&dm); } }); }); diff --git a/buffa-codegen/src/impl_message.rs b/buffa-codegen/src/impl_message.rs index 98c3144..ed991ca 100644 --- a/buffa-codegen/src/impl_message.rs +++ b/buffa-codegen/src/impl_message.rs @@ -598,20 +598,45 @@ pub fn generate_message_impl( "e! { #name_ident }, ); - // Bridge-mode reflection: `impl Reflectable` resolving against the - // package's embedded descriptor pool. Skipped for map entry synthetic - // messages — they're not registered in the pool by name and consumers - // never reflect over them directly. - let reflectable_impl = if ctx.config.generate_reflection - && !msg - .options - .as_option() - .is_some_and(|o| o.map_entry.unwrap_or(false)) - { - crate::feature_gates::cfg_block( - crate::reflect::reflectable_impl("e! { #name_ident }, "e! { __buffa }), - ctx.config.feature_gates().reflect, - ) + // Reflection: `impl Reflectable` resolving against the package's embedded + // descriptor pool. Skipped for map entry synthetic messages — they're not + // registered in the pool by name and consumers never reflect over them. + // + // In vtable mode this also emits `impl ReflectMessage` / `impl + // ReflectElement` on the owned struct and makes `reflect()` borrow `self` + // directly (no encode/decode round-trip). In bridge mode `reflect()` boxes + // a `DynamicMessage` from a round-trip. + let is_map_entry = msg + .options + .as_option() + .is_some_and(|o| o.map_entry.unwrap_or(false)); + let reflectable_impl = if ctx.config.generate_reflection && !is_map_entry { + let gate = ctx.config.feature_gates().reflect; + if ctx.config.generate_reflection_vtable { + let buffa_path = quote! { __buffa }; + let owned = crate::reflect_owned::reflect_owned_impls( + &crate::reflect_owned::OwnedReflectScope { + ctx, + msg, + name_ident: &name_ident, + buffa_path: &buffa_path, + current_package, + features, + oneof_idents, + oneof_prefix, + nesting, + }, + )?; + let reflect_body = crate::reflect::reflectable_impl_vtable("e! { #name_ident }); + // Multiple sibling impls (ReflectMessage, ReflectElement, the memo + // inherent impl, Reflectable) — gate them together with one cfg. + crate::feature_gates::cfg_const_block(quote! { #owned #reflect_body }, gate) + } else { + crate::feature_gates::cfg_block( + crate::reflect::reflectable_impl("e! { #name_ident }, "e! { __buffa }), + gate, + ) + } } else { quote! {} }; diff --git a/buffa-codegen/src/lib.rs b/buffa-codegen/src/lib.rs index c6a1110..28aefca 100644 --- a/buffa-codegen/src/lib.rs +++ b/buffa-codegen/src/lib.rs @@ -36,6 +36,7 @@ pub(crate) mod imports; pub(crate) mod message; pub(crate) mod oneof; pub(crate) mod reflect; +pub(crate) mod reflect_owned; pub(crate) mod reflect_view; pub(crate) mod view; @@ -478,15 +479,20 @@ pub struct CodeGenConfig { /// /// Defaults to `false`. pub generate_reflection: bool, - /// Additionally emit `impl ReflectMessage` / `impl ReflectElement` on view - /// types (vtable mode), on top of the bridge-mode `Reflectable` impl. + /// Emit vtable-mode reflection: `impl ReflectMessage` / `impl + /// ReflectElement` on **both** the view types and the owned message + /// structs, and switch the owned `Reflectable::reflect()` body to borrow + /// `self` (`ReflectCow::Borrowed(self)`) instead of the bridge round-trip. /// - /// Requires [`generate_reflection`](Self::generate_reflection) (the vtable - /// impls resolve against the same embedded `DescriptorPool`) and - /// [`generate_views`](Self::generate_views). Internal flag, not yet exposed - /// through `buffa-build`; the public `ReflectMode` surface is wired - /// separately. Vtable mode reads view struct fields directly — no - /// encode/decode round-trip and no per-field allocation. + /// Reflective access then reads struct fields in place — no encode/decode + /// round-trip and no per-field allocation — for both a decoded view and an + /// in-memory owned message. + /// + /// Requires [`generate_reflection`](Self::generate_reflection) (the impls + /// resolve against the same embedded `DescriptorPool`) and + /// [`generate_views`](Self::generate_views). Internal flag, exposed + /// experimentally through `buffa_build::Config::generate_reflection_vtable` + /// until the public `ReflectMode` surface lands. /// /// Defaults to `false`. pub generate_reflection_vtable: bool, diff --git a/buffa-codegen/src/reflect.rs b/buffa-codegen/src/reflect.rs index a78253b..e64bd8b 100644 --- a/buffa-codegen/src/reflect.rs +++ b/buffa-codegen/src/reflect.rs @@ -1,17 +1,24 @@ -//! Code generation for `impl Reflectable` (bridge mode). +//! Code generation for the owned message's `impl Reflectable` and the +//! per-package descriptor pool. //! -//! Wired through [`CodeGenConfig::generate_reflection`]. When enabled, each -//! generated owned message gets an `impl ::buffa_descriptor::reflect::Reflectable` -//! that round-trips through [`DynamicMessage`](buffa_descriptor::DynamicMessage) -//! (encode → decode → reflective handle), plus a per-package -//! `__buffa::reflect` submodule embedding the `FileDescriptorSet` bytes and -//! a lazy [`DescriptorPool`](buffa_descriptor::DescriptorPool) accessor. +//! Wired through [`CodeGenConfig::generate_reflection`]. Every generated owned +//! message gets an `impl ::buffa_descriptor::reflect::Reflectable`, plus a +//! per-package `__buffa::reflect` submodule embedding the `FileDescriptorSet` +//! bytes and a lazy [`DescriptorPool`](buffa_descriptor::DescriptorPool) +//! accessor that both modes resolve against. //! -//! The bridge mode is the v1 reflection target. The vtable mode (zero-copy -//! reflective access without the round-trip) is deferred — see -//! `docs/investigations/reflection.md`. The call-site contract is the same -//! either way (`foo.reflect().get(fd)`), so flipping modes later requires no -//! diff in consumer code. +//! Two `reflect()` bodies are emitted, selected by mode: +//! +//! - **Bridge** ([`reflectable_impl`]) — round-trips through +//! [`DynamicMessage`](buffa_descriptor::DynamicMessage) (encode → decode → +//! boxed handle). +//! - **Vtable** ([`reflectable_impl_vtable`]) — returns +//! `ReflectCow::Borrowed(self)`, with no round-trip. Requires the owned +//! `impl ReflectMessage` emitted by [`reflect_owned`](crate::reflect_owned) +//! (and the view impls by [`reflect_view`](crate::reflect_view)). +//! +//! The call-site contract is identical (`foo.reflect().get(fd)`), so flipping a +//! message between modes requires no diff in consumer code. //! //! ## Runtime requirements //! @@ -82,6 +89,23 @@ pub(crate) fn reflectable_impl(ty: &TokenStream, buffa_path: &TokenStream) -> To } } +/// Generate the vtable-mode `impl Reflectable for #ty`, whose `reflect()` +/// borrows `self` directly as `ReflectCow::Borrowed(self)` — no encode/decode +/// round-trip. Requires `#ty: ReflectMessage` (the owned vtable impl emitted by +/// [`reflect_owned`](crate::reflect_owned)). +pub(crate) fn reflectable_impl_vtable(ty: &TokenStream) -> TokenStream { + quote! { + impl ::buffa_descriptor::reflect::Reflectable for #ty { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } + } +} + /// Serialize the full `FileDescriptorSet` once per codegen run. /// /// `reflect_pool_module` is invoked once per package, so without caching @@ -109,8 +133,9 @@ pub(crate) fn encode_fds_once(file_descriptors: &[FileDescriptorProto]) -> Vec TokenStream { let byte_literals = fds_bytes.iter().map(|b| quote! { #b }); quote! { - /// Reflection support: embedded descriptor pool for bridge-mode - /// [`Reflectable`](::buffa_descriptor::reflect::Reflectable) impls. + /// Reflection support: embedded descriptor pool shared by this + /// package's [`Reflectable`](::buffa_descriptor::reflect::Reflectable) + /// and `ReflectMessage` impls (bridge and vtable mode alike). pub mod reflect { /// The serialized `FileDescriptorSet` for this codegen run, /// including transitive dependencies. Used to build the diff --git a/buffa-codegen/src/reflect_owned.rs b/buffa-codegen/src/reflect_owned.rs new file mode 100644 index 0000000..21247e3 --- /dev/null +++ b/buffa-codegen/src/reflect_owned.rs @@ -0,0 +1,355 @@ +//! Code generation for vtable-mode reflection on owned message types. +//! +//! Parallel to [`reflect_view`](crate::reflect_view), but for the owned struct +//! rather than the zero-copy view. When vtable mode is on, each owned message +//! gets: +//! +//! - `impl ReflectMessage for Foo` — reads owned struct fields directly +//! (`String`/`Vec`/`MessageField`/`Vec`/`HashMap`/owned oneof enum), +//! backed by the owned-container reflect impls in `buffa-descriptor`. +//! - `impl ReflectElement for Foo` — so a `Vec` / `HashMap<_, Foo>` +//! reflects through the generic container impls. +//! - A memoized per-message `MessageIndex` accessor. +//! +//! The owned `Reflectable::reflect()` body is then `ReflectCow::Borrowed(self)` +//! (emitted by [`reflect`](crate::reflect)), so reflecting an in-memory message +//! costs no encode/decode round-trip — the interceptor use case. Bridge mode +//! keeps the round-trip body and emits none of this. + +use std::collections::HashMap; + +use proc_macro2::TokenStream; +use quote::quote; + +use crate::context::CodeGenContext; +use crate::features::{resolve_field, ResolvedFeatures}; +use crate::generated::descriptor::field_descriptor_proto::{Label, Type}; +use crate::generated::descriptor::DescriptorProto; +use crate::idents::make_field_ident; +use crate::impl_message::{ + effective_type, is_explicit_presence_scalar, is_real_oneof_member, is_supported_field_type, +}; +use crate::message::{is_closed_enum, is_map_field, rust_path_to_tokens}; +use crate::oneof::oneof_variant_ident; +use crate::reflect_view::{scalar_default, scalar_variant}; +use crate::CodeGenError; + +/// Context needed to emit the owned-message vtable impls, mirroring the +/// arguments [`generate_message_impl`](crate::impl_message::generate_message_impl) +/// already has in hand. +pub(crate) struct OwnedReflectScope<'a> { + pub ctx: &'a CodeGenContext<'a>, + pub msg: &'a DescriptorProto, + pub name_ident: &'a proc_macro2::Ident, + pub buffa_path: &'a TokenStream, + pub current_package: &'a str, + pub features: &'a ResolvedFeatures, + pub oneof_idents: &'a HashMap, + pub oneof_prefix: &'a TokenStream, + pub nesting: usize, +} + +/// Generate `impl ReflectMessage` + `impl ReflectElement` + the memoized +/// `MessageIndex` accessor for an owned message. +pub(crate) fn reflect_owned_impls( + scope: &OwnedReflectScope<'_>, +) -> Result { + let ctx = scope.ctx; + let msg = scope.msg; + let name_ident = scope.name_ident; + let buffa_path = scope.buffa_path; + let current_package = scope.current_package; + let features = scope.features; + let oneof_idents = scope.oneof_idents; + let oneof_prefix = scope.oneof_prefix; + let nesting = scope.nesting; + let vr = quote! { ::buffa_descriptor::reflect::ValueRef }; + let cow = quote! { ::buffa_descriptor::reflect::ReflectCow }; + + let mut get_arms: Vec = Vec::new(); + let mut has_arms: Vec = Vec::new(); + + // Direct (non-oneof) fields. + for field in &msg.field { + if is_real_oneof_member(field) { + continue; + } + let ty = effective_type(ctx, field, features); + if !is_supported_field_type(ty) { + continue; + } + let name = field + .name + .as_deref() + .ok_or(CodeGenError::MissingField("field.name"))?; + let id = make_field_ident(name); + let number = field.number.unwrap_or(0) as u32; + let is_repeated = field.label.unwrap_or_default() == Label::LABEL_REPEATED; + + if is_repeated && is_map_field(msg, field) { + get_arms.push(quote! { #number => #vr::Map(&self.#id), }); + has_arms.push(quote! { #number => !self.#id.is_empty(), }); + continue; + } + if is_repeated { + get_arms.push(quote! { #number => #vr::List(&self.#id), }); + has_arms.push(quote! { #number => !self.#id.is_empty(), }); + continue; + } + + let f_features = resolve_field(ctx, field, features); + let (get_val, has_val) = if is_explicit_presence_scalar(field, ty, &f_features) { + // Stored as `Option`; absent singular returns the type default. + match ty { + Type::TYPE_STRING => ( + quote! { #vr::String(self.#id.as_deref().unwrap_or("")) }, + quote! { self.#id.is_some() }, + ), + Type::TYPE_BYTES => ( + quote! { #vr::Bytes(self.#id.as_deref().unwrap_or(&[])) }, + quote! { self.#id.is_some() }, + ), + Type::TYPE_ENUM => ( + quote! { #vr::EnumNumber(self.#id.map_or(0, |e| e.to_i32())) }, + quote! { self.#id.is_some() }, + ), + _ => { + let variant = scalar_variant(ty); + let def = scalar_default(ty); + ( + quote! { #vr::#variant(self.#id.unwrap_or(#def)) }, + quote! { self.#id.is_some() }, + ) + } + } + } else { + // Implicit presence: absent is the default value, present is + // non-default. proto2 `required` fields also fall here (stored as + // bare types), so a required field set to its default reflects as + // `has() == false` — the same limitation the view path documents. + match ty { + Type::TYPE_STRING => ( + quote! { #vr::String(&self.#id) }, + quote! { !self.#id.is_empty() }, + ), + Type::TYPE_BYTES => ( + quote! { #vr::Bytes(&self.#id[..]) }, + quote! { !self.#id.is_empty() }, + ), + Type::TYPE_MESSAGE | Type::TYPE_GROUP => ( + // `MessageField` derefs to the inner message, or the static + // default instance when unset, so the borrow is always valid. + quote! { #vr::Message(#cow::Borrowed(&*self.#id)) }, + quote! { self.#id.is_set() }, + ), + Type::TYPE_ENUM => { + let has_val = if is_closed_enum(&f_features) { + quote! { self.#id != ::core::default::Default::default() } + } else { + quote! { self.#id.to_i32() != 0 } + }; + (quote! { #vr::EnumNumber(self.#id.to_i32()) }, has_val) + } + _ => { + let variant = scalar_variant(ty); + let has_val = match ty { + Type::TYPE_BOOL => quote! { self.#id }, + Type::TYPE_FLOAT | Type::TYPE_DOUBLE => quote! { self.#id != 0.0 }, + _ => quote! { self.#id != 0 }, + }; + (quote! { #vr::#variant(self.#id) }, has_val) + } + } + }; + get_arms.push(quote! { #number => #get_val, }); + has_arms.push(quote! { #number => #has_val, }); + } + + // Oneof members dispatch through the `Option` struct field. + for (idx, oneof) in msg.oneof_decl.iter().enumerate() { + let Some(base_ident) = oneof_idents.get(&idx) else { + continue; + }; + let oneof_name = oneof + .name + .as_deref() + .ok_or(CodeGenError::MissingField("oneof.name"))?; + let field_ident = make_field_ident(oneof_name); + let oneof_enum = quote! { #oneof_prefix #base_ident }; + + for field in msg + .field + .iter() + .filter(|f| is_real_oneof_member(f) && f.oneof_index == Some(idx as i32)) + { + let name = field + .name + .as_deref() + .ok_or(CodeGenError::MissingField("field.name"))?; + let number = field.number.unwrap_or(0) as u32; + let variant = oneof_variant_ident(name); + let ty = effective_type(ctx, field, features); + + let (active, default) = match ty { + Type::TYPE_STRING => (quote! { #vr::String(v) }, quote! { #vr::String("") }), + Type::TYPE_BYTES => (quote! { #vr::Bytes(&v[..]) }, quote! { #vr::Bytes(&[]) }), + Type::TYPE_MESSAGE | Type::TYPE_GROUP => { + let owned_ty = resolve_owned_message_ty(ctx, field, current_package, nesting)?; + ( + quote! { #vr::Message(#cow::Borrowed(&**v)) }, + quote! { + #vr::Message(#cow::Borrowed( + <#owned_ty as ::buffa::DefaultInstance>::default_instance(), + )) + }, + ) + } + Type::TYPE_ENUM => ( + quote! { #vr::EnumNumber(v.to_i32()) }, + quote! { #vr::EnumNumber(0) }, + ), + _ => { + let variant_v = scalar_variant(ty); + let def = scalar_default(ty); + ( + quote! { #vr::#variant_v(*v) }, + quote! { #vr::#variant_v(#def) }, + ) + } + }; + + get_arms.push(quote! { + #number => match &self.#field_ident { + ::core::option::Option::Some(#oneof_enum::#variant(v)) => #active, + _ => #default, + }, + }); + has_arms.push(quote! { + #number => ::core::matches!( + &self.#field_ident, + ::core::option::Option::Some(#oneof_enum::#variant(_)) + ), + }); + } + } + + let pool = quote! { #buffa_path::reflect::descriptor_pool() }; + + // Preserve unknown fields through reflection, matching the bridge path + // (`DynamicMessage` carries them). Without this override the trait default + // returns an empty set, so a recursive reflective walk over nested messages + // would silently drop fields the local schema doesn't know — the exact + // regression `ReflectMessage::unknown_fields`'s own doc warns against. + let unknown_fields_method = if ctx.config.preserve_unknown_fields { + quote! { + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + } + } else { + quote! {} + }; + + Ok(quote! { + impl ::buffa_descriptor::reflect::ReflectMessage for #name_ident { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + #pool.message(Self::__buffa_reflect_message_index()) + } + + fn pool(&self) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + #pool + } + + #unknown_fields_method + + fn get(&self, field: &::buffa_descriptor::FieldDescriptor) -> #vr<'_> { + // Closed enums use the `Enumeration` trait `to_i32`; open enums + // (`EnumValue`) use the inherent one. No-op import for messages + // without enum fields. + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + #(#get_arms)* + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + #vr::Bool(false) + } + } + } + + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + #(#has_arms)* + _ => false, + } + } + + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut(&::buffa_descriptor::FieldDescriptor, #vr<'_>), + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor(self); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(#pool), + Self::__buffa_reflect_message_index(), + ) + } + } + + impl ::buffa_descriptor::reflect::ReflectElement for #name_ident { + fn as_value_ref(&self) -> #vr<'_> { + #vr::Message(#cow::Borrowed(self)) + } + } + + impl #name_ident { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = + ::std::sync::OnceLock::new(); + *IDX.get_or_init(|| { + #pool + .message_index(::FULL_NAME) + .expect("generated message is registered in the embedded descriptor pool") + }) + } + } + }) +} + +/// Resolve the owned Rust type token for a message-typed oneof member, used for +/// the unset-member default (`::default_instance()`). +fn resolve_owned_message_ty( + ctx: &CodeGenContext, + field: &crate::generated::descriptor::FieldDescriptorProto, + current_package: &str, + nesting: usize, +) -> Result { + let dotted = field + .type_name + .as_deref() + .ok_or(CodeGenError::MissingField("field.type_name"))?; + let path = ctx + .rust_type_relative(dotted, current_package, nesting) + .ok_or_else(|| { + CodeGenError::Other(format!( + "owned type for oneof message '{dotted}' not resolvable" + )) + })?; + Ok(rust_path_to_tokens(&path)) +} diff --git a/buffa-codegen/src/reflect_view.rs b/buffa-codegen/src/reflect_view.rs index e07f0dc..1399851 100644 --- a/buffa-codegen/src/reflect_view.rs +++ b/buffa-codegen/src/reflect_view.rs @@ -40,7 +40,7 @@ use crate::CodeGenError; /// Mirrors the wire form, matching `DynamicMessage`: `int32`/`sint32`/`sfixed32` /// all map to `I32`, etc. String, bytes, enum, and message types are handled by /// the callers, not here. -fn scalar_variant(ty: Type) -> TokenStream { +pub(crate) fn scalar_variant(ty: Type) -> TokenStream { match ty { Type::TYPE_INT32 | Type::TYPE_SINT32 | Type::TYPE_SFIXED32 => quote! { I32 }, Type::TYPE_INT64 | Type::TYPE_SINT64 | Type::TYPE_SFIXED64 => quote! { I64 }, @@ -55,7 +55,7 @@ fn scalar_variant(ty: Type) -> TokenStream { } /// The default literal for a wire-numeric proto type (`0`, `0.0`, or `false`). -fn scalar_default(ty: Type) -> TokenStream { +pub(crate) fn scalar_default(ty: Type) -> TokenStream { match ty { Type::TYPE_BOOL => quote! { false }, Type::TYPE_FLOAT | Type::TYPE_DOUBLE => quote! { 0.0 }, diff --git a/buffa-descriptor/src/reflect/view.rs b/buffa-descriptor/src/reflect/containers.rs similarity index 93% rename from buffa-descriptor/src/reflect/view.rs rename to buffa-descriptor/src/reflect/containers.rs index a8b475a..c85a472 100644 --- a/buffa-descriptor/src/reflect/view.rs +++ b/buffa-descriptor/src/reflect/containers.rs @@ -44,17 +44,27 @@ use super::value::{MapKey, MapKeyRef, ReflectList, ReflectMap, Value, ValueRef}; /// Conversion of a single repeated-field element (or map value) to a borrowed /// [`ValueRef`]. /// -/// Implemented here for the closed set of view element types (scalars, `&str`, -/// `&[u8]`, [`EnumValue`]). Codegen emits a one-line impl for each generated -/// message view type (yielding [`ValueRef::Message`]) and each bare closed -/// enum (yielding [`ValueRef::EnumNumber`]) — these cannot be covered by a -/// blanket impl without colliding with the scalar impls under Rust's coherence -/// rules. +/// Implemented here for the closed set of element types the runtime knows: +/// scalars, `&str` / `&[u8]` (view storage), `String` / `Vec` / +/// [`Bytes`](buffa::bytes::Bytes) (owned storage), [`EnumValue`], and +/// [`Value`](super::Value) (bridge storage). Codegen emits a one-line impl for +/// each generated message type (view and owned, yielding [`ValueRef::Message`]) +/// and each bare closed enum (yielding [`ValueRef::EnumNumber`]) — these cannot +/// be covered by a blanket impl without colliding with the scalar impls under +/// Rust's coherence rules. /// -/// A hand-written or codegen-emitted implementer must also derive [`Debug`]: -/// the [`core::fmt::Debug`] supertrait is what lets the generic [`ReflectList`] -/// / [`ReflectMap`] impls below satisfy *their* own `Debug` supertrait through -/// the `RepeatedView: Debug` / `MapView: Debug` derives. +/// # Contract +/// +/// `as_value_ref` must return the **same variant** on every call for a given +/// value — the generic [`ReflectList`] / [`ReflectMap`] impls and their callers +/// assume a `Vec` / `HashMap<_, T>` is homogeneous. An implementer must also +/// derive [`Debug`] (the supertrait lets the generic container impls satisfy +/// *their* `Debug` supertrait through the container's derive). +/// +/// Note: the non-default `string_type` representations (`SmolStr`, +/// `EcoString`, `CompactString`) are **not** implemented here — a `repeated` +/// string field generated with one of those plus vtable mode would need a +/// matching impl. Both knobs are experimental, so this is a known gap. pub trait ReflectElement: core::fmt::Debug { /// Borrow this element as a [`ValueRef`]. #[must_use] diff --git a/buffa-descriptor/src/reflect/message.rs b/buffa-descriptor/src/reflect/message.rs index d2857e2..5e3681d 100644 --- a/buffa-descriptor/src/reflect/message.rs +++ b/buffa-descriptor/src/reflect/message.rs @@ -118,12 +118,14 @@ pub trait ReflectMessage { None } - /// Snapshot this message as a [`DynamicMessage`]. - /// - /// For an already-dynamic message this is a clone; for a generated - /// message in bridge mode this is the encode/decode round-trip. The - /// default implementation is provided so that `dyn ReflectMessage` can - /// be converted, which `ReflectCow::to_dynamic` needs. + /// Snapshot this message as an owned [`DynamicMessage`]. + /// + /// For an already-dynamic message this is a clone; for a generated message + /// (bridge or vtable mode) this is an encode/decode round-trip. Required + /// rather than defaulted so that a `dyn ReflectMessage` can always be + /// converted, which [`ReflectCow::to_dynamic`] relies on — and so a + /// borrowed vtable handle can be promoted to an owned snapshot that + /// outlives `self`. fn to_dynamic(&self) -> DynamicMessage; } @@ -213,30 +215,37 @@ pub trait Reflectable { /// /// # Performance /// - /// In the codegen-emitted **bridge mode** impl, `reflect()` is one full - /// encode + decode round-trip plus a heap allocation per call. Hold - /// onto the returned handle for repeated field reads rather than - /// calling `reflect()` per field. The first call also pays a one-time - /// pool build cost (linking the embedded `FileDescriptorSet`). + /// Which body codegen emits depends on the reflection mode: + /// + /// - **Bridge mode** — `reflect()` is one full encode + decode round-trip + /// plus a heap allocation per call, returning an owned `DynamicMessage` + /// snapshot. The first call also pays a one-time pool build cost (linking + /// the embedded `FileDescriptorSet`). + /// - **Vtable mode** — `reflect()` borrows `self` directly + /// (`ReflectCow::Borrowed`), with no round-trip and no allocation; the + /// reflective accessors read the message's fields in place. /// - /// The vtable mode (deferred) is a borrow with no round-trip; the call - /// site doesn't change between modes. + /// Either way the returned handle borrows `self` (the signature ties it to + /// `&self`), so the call site is identical between modes. Hold onto the + /// handle for repeated reads rather than calling `reflect()` per field; for + /// an owned snapshot that outlives `self`, use + /// [`ReflectCow::to_dynamic`](super::ReflectCow::to_dynamic). /// /// # Panics /// - /// The codegen-emitted bridge impl panics if the embedded - /// `FileDescriptorSet` is malformed or `Self::FULL_NAME` is not - /// registered in the package pool — both indicate a codegen bug, not - /// consumer misuse. + /// The bridge-mode body panics if the embedded `FileDescriptorSet` is + /// malformed or `Self::FULL_NAME` is not registered in the package pool — + /// both indicate a codegen bug, not consumer misuse. (Vtable mode resolves + /// the descriptor lazily on first access with the same invariant.) /// /// # Setup /// /// The `Reflectable` impl is generated by enabling - /// `buffa_build::Config::generate_reflection(true)` in `build.rs`. The - /// consuming crate must also depend on `buffa-descriptor` with its - /// `reflect` feature and on `std`. See the `generate_reflection` doc - /// for the `Cargo.toml` pattern. - #[must_use = "reflect() round-trips through encode/decode in bridge mode; bind the handle"] + /// `buffa_build::Config::generate_reflection(true)` (bridge) or + /// `generate_reflection_vtable(true)` (vtable) in `build.rs`. The consuming + /// crate must also depend on `buffa-descriptor` with its `reflect` feature + /// and on `std`. + #[must_use = "reflect() returns a reflective handle borrowing self; bind it before reading fields"] fn reflect(&self) -> ReflectCow<'_>; // `reflect_mut(&mut self) -> ReflectCowMut<'_>` is part of the design but diff --git a/buffa-descriptor/src/reflect/mod.rs b/buffa-descriptor/src/reflect/mod.rs index 5cf04da..69a3309 100644 --- a/buffa-descriptor/src/reflect/mod.rs +++ b/buffa-descriptor/src/reflect/mod.rs @@ -22,19 +22,19 @@ //! also the natural home, since reflection consumers already declare //! `buffa-descriptor` for the descriptor types. +mod containers; mod dynamic; #[cfg(feature = "json")] mod json; mod message; mod value; -mod view; +pub use containers::{ReflectElement, ReflectMapKey}; pub use dynamic::{AnyError, DynamicMessage}; #[cfg(feature = "json")] pub use json::DynamicMessageSeed; pub use message::{ReflectCow, ReflectMessage, ReflectMessageMut, Reflectable}; pub use value::{MapKey, MapKeyRef, MapValue, ReflectList, ReflectMap, Value, ValueRef}; -pub use view::{ReflectElement, ReflectMapKey}; /// Per-message reflection mode, selected at codegen time. /// diff --git a/buffa-test/tests/reflect_vtable.rs b/buffa-test/tests/reflect_vtable.rs index 9f2c269..6c7f37e 100644 --- a/buffa-test/tests/reflect_vtable.rs +++ b/buffa-test/tests/reflect_vtable.rs @@ -8,7 +8,7 @@ //! reflection consumer holding raw bytes (an interceptor, a field-mask //! evaluator) uses. -use buffa::{Message, MessageView}; +use buffa::{Message, MessageView, OwnedView}; use buffa_descriptor::reflect::{MapKey, ReflectMessage, ValueRef}; use buffa_test::basic::*; @@ -221,3 +221,20 @@ fn vtable_to_dynamic_snapshot() { ValueRef::I32(42) )); } + +#[test] +fn vtable_owned_view_entry_point() { + // The entry point a reflection consumer holding raw wire bytes uses: wrap + // them in an `OwnedView` (lifetime-erased), reborrow to a tied-lifetime + // view, and reflect through `&dyn ReflectMessage`. + let bytes = buffa::bytes::Bytes::from(person_bytes()); + let owned = OwnedView::>::decode(bytes).expect("OwnedView::decode"); + let view = owned.reborrow(); + let r: &dyn ReflectMessage = view; + let md = r.message_descriptor(); + assert!(matches!(r.get(md.field(1).unwrap()), ValueRef::I32(42))); + assert!(matches!( + r.get(md.field(2).unwrap()), + ValueRef::String("Ada") + )); +} diff --git a/buffa-test/tests/reflectable.rs b/buffa-test/tests/reflectable.rs index b472625..178c6ca 100644 --- a/buffa-test/tests/reflectable.rs +++ b/buffa-test/tests/reflectable.rs @@ -107,6 +107,96 @@ fn for_each_set_visits_set_fields() { assert_eq!(seen, vec!["id", "score", "verified"]); } +#[test] +fn owned_vtable_matches_bridge_for_every_field() { + use buffa_descriptor::reflect::DynamicMessage; + use buffa_test::basic::{person, Inventory, Status}; + use std::sync::Arc; + + // A Person exercising every owned-vtable arm: scalars, string, bytes, + // bool, double, enum, nested message, repeated string + repeated scalar, + // explicit-presence optional, and a oneof. + let person = Person { + id: 42, + name: "Ada".into(), + avatar: vec![0xDE, 0xAD], + verified: true, + score: 9.5, + status: Status::ACTIVE.into(), + address: MessageField::some(Address { + street: "1 Main".into(), + zip_code: 12345, + ..Default::default() + }), + tags: vec!["x".into(), "y".into()], + lucky_numbers: vec![7, 11, 13], + maybe_age: Some(30), + contact: Some(person::Contact::Email("ada@example.com".into())), + ..Default::default() + }; + + // Compare the vtable reflection (reflect() → Borrowed(self)) against the + // bridge round-trip, field by field. `ValueRef` has no `PartialEq` (trait + // objects), so compare the owned `Value` snapshots. + let vt = person.reflect(); + let md = vt.message_descriptor(); + let pool = Arc::clone(vt.pool()); + let idx = pool.message_index("basic.Person").unwrap(); + let bridge = DynamicMessage::from_message(&person, Arc::clone(&pool), idx); + + for fd in md.fields() { + assert_eq!( + vt.has(fd), + bridge.has(fd), + "has() mismatch on field {}", + fd.number() + ); + if vt.has(fd) { + assert_eq!( + vt.get(fd).to_owned(), + bridge.get(fd).to_owned(), + "get() mismatch on field {}", + fd.number() + ); + } + } + + // Map fields (Inventory.stock: map) — separate message. + let mut stock = std::collections::HashMap::new(); + stock.insert("apples".to_string(), 3); + stock.insert("oranges".to_string(), 7); + let inv = Inventory { + stock, + ..Default::default() + }; + let inv_vt = inv.reflect(); + let inv_md = inv_vt.message_descriptor(); + let inv_idx = pool.message_index("basic.Inventory").unwrap(); + let inv_bridge = DynamicMessage::from_message(&inv, Arc::clone(&pool), inv_idx); + let stock_fd = inv_md + .fields() + .iter() + .find(|f| f.name() == "stock") + .unwrap(); + assert_eq!( + inv_vt.get(stock_fd).to_owned(), + inv_bridge.get(stock_fd).to_owned(), + "map field mismatch" + ); +} + +#[test] +fn reflect_borrows_in_vtable_mode() { + use buffa_descriptor::reflect::ReflectCow; + // basic.proto is generated with vtable mode, so `reflect()` borrows `self` + // directly (no `DynamicMessage` round-trip / heap allocation). + let person = Person { + id: 1, + ..Default::default() + }; + assert!(matches!(person.reflect(), ReflectCow::Borrowed(_))); +} + #[test] fn descriptor_pool_is_built_once() { // The pool is `OnceLock`-backed; multiple `reflect()` calls share it. diff --git a/buffa-types/Cargo.toml b/buffa-types/Cargo.toml index 632820d..9a99d10 100644 --- a/buffa-types/Cargo.toml +++ b/buffa-types/Cargo.toml @@ -22,7 +22,7 @@ arbitrary = ["dep:arbitrary", "buffa/arbitrary"] # etc.) and owned types. Pulls `buffa-descriptor` and requires `std` (the # embedded descriptor pool uses `std::sync::OnceLock`). Off by default so # `no_std` consumers and those that don't reflect pay nothing. -reflect = ["dep:buffa-descriptor", "buffa-descriptor/reflect", "std"] +reflect = ["dep:buffa-descriptor", "buffa-descriptor/reflect", "buffa-descriptor/std", "std"] [dependencies] arbitrary = { workspace = true, optional = true } diff --git a/buffa-types/src/generated/google.protobuf.any.rs b/buffa-types/src/generated/google.protobuf.any.rs index c8d3ce9..276ba07 100644 --- a/buffa-types/src/generated/google.protobuf.any.rs +++ b/buffa-types/src/generated/google.protobuf.any.rs @@ -165,48 +165,102 @@ impl ::buffa::DefaultInstance for Any { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Any { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Any { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::String(&self.type_url), + 2u32 => ::buffa_descriptor::reflect::ValueRef::Bytes(&self.value[..]), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.type_url.is_empty(), + 2u32 => !self.value.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Any { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Any { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Any { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Any { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Any"; diff --git a/buffa-types/src/generated/google.protobuf.duration.rs b/buffa-types/src/generated/google.protobuf.duration.rs index 811bf90..a117497 100644 --- a/buffa-types/src/generated/google.protobuf.duration.rs +++ b/buffa-types/src/generated/google.protobuf.duration.rs @@ -108,48 +108,102 @@ impl ::buffa::DefaultInstance for Duration { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Duration { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Duration { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I64(self.seconds), + 2u32 => ::buffa_descriptor::reflect::ValueRef::I32(self.nanos), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.seconds != 0, + 2u32 => self.nanos != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Duration { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Duration { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Duration { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Duration { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Duration"; diff --git a/buffa-types/src/generated/google.protobuf.empty.rs b/buffa-types/src/generated/google.protobuf.empty.rs index f3adc0d..5cd41b2 100644 --- a/buffa-types/src/generated/google.protobuf.empty.rs +++ b/buffa-types/src/generated/google.protobuf.empty.rs @@ -35,48 +35,98 @@ impl ::buffa::DefaultInstance for Empty { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Empty { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Empty { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Empty { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Empty { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Empty { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Empty { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Empty"; diff --git a/buffa-types/src/generated/google.protobuf.field_mask.rs b/buffa-types/src/generated/google.protobuf.field_mask.rs index 592ff41..37c9173 100644 --- a/buffa-types/src/generated/google.protobuf.field_mask.rs +++ b/buffa-types/src/generated/google.protobuf.field_mask.rs @@ -253,48 +253,100 @@ impl ::buffa::DefaultInstance for FieldMask { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for FieldMask { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for FieldMask { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::List(&self.paths), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.paths.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for FieldMask { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl FieldMask { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for FieldMask { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for FieldMask { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "FieldMask"; diff --git a/buffa-types/src/generated/google.protobuf.mod.rs b/buffa-types/src/generated/google.protobuf.mod.rs index abd823e..1a01986 100644 --- a/buffa-types/src/generated/google.protobuf.mod.rs +++ b/buffa-types/src/generated/google.protobuf.mod.rs @@ -43,8 +43,9 @@ pub mod __buffa { include!("google.protobuf.struct.__oneof.rs"); } #[cfg(feature = "reflect")] - /// Reflection support: embedded descriptor pool for bridge-mode - /// [`Reflectable`](::buffa_descriptor::reflect::Reflectable) impls. + /// Reflection support: embedded descriptor pool shared by this + /// package's [`Reflectable`](::buffa_descriptor::reflect::Reflectable) + /// and `ReflectMessage` impls (bridge and vtable mode alike). pub mod reflect { /// The serialized `FileDescriptorSet` for this codegen run, /// including transitive dependencies. Used to build the diff --git a/buffa-types/src/generated/google.protobuf.struct.rs b/buffa-types/src/generated/google.protobuf.struct.rs index ad4f3e2..7d2ef51 100644 --- a/buffa-types/src/generated/google.protobuf.struct.rs +++ b/buffa-types/src/generated/google.protobuf.struct.rs @@ -79,48 +79,100 @@ impl ::buffa::DefaultInstance for Struct { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Struct { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Struct { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::Map(&self.fields), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.fields.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Struct { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Struct { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Struct { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Struct { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Struct"; @@ -399,48 +451,204 @@ impl ::buffa::DefaultInstance for Value { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Value { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Value { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => { + match &self.kind { + ::core::option::Option::Some( + __buffa::oneof::value::Kind::NullValue(v), + ) => { + ::buffa_descriptor::reflect::ValueRef::EnumNumber(v.to_i32()) + } + _ => ::buffa_descriptor::reflect::ValueRef::EnumNumber(0), + } + } + 2u32 => { + match &self.kind { + ::core::option::Option::Some( + __buffa::oneof::value::Kind::NumberValue(v), + ) => ::buffa_descriptor::reflect::ValueRef::F64(*v), + _ => ::buffa_descriptor::reflect::ValueRef::F64(0.0), + } + } + 3u32 => { + match &self.kind { + ::core::option::Option::Some( + __buffa::oneof::value::Kind::StringValue(v), + ) => ::buffa_descriptor::reflect::ValueRef::String(v), + _ => ::buffa_descriptor::reflect::ValueRef::String(""), + } + } + 4u32 => { + match &self.kind { + ::core::option::Option::Some( + __buffa::oneof::value::Kind::BoolValue(v), + ) => ::buffa_descriptor::reflect::ValueRef::Bool(*v), + _ => ::buffa_descriptor::reflect::ValueRef::Bool(false), + } + } + 5u32 => { + match &self.kind { + ::core::option::Option::Some( + __buffa::oneof::value::Kind::StructValue(v), + ) => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(&**v), + ) + } + _ => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed( + ::default_instance(), + ), + ) + } + } + } + 6u32 => { + match &self.kind { + ::core::option::Option::Some( + __buffa::oneof::value::Kind::ListValue(v), + ) => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(&**v), + ) + } + _ => { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed( + ::default_instance(), + ), + ) + } + } + } + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(__buffa::oneof::value::Kind::NullValue(_)) + ) + } + 2u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(__buffa::oneof::value::Kind::NumberValue(_)) + ) + } + 3u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(__buffa::oneof::value::Kind::StringValue(_)) + ) + } + 4u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(__buffa::oneof::value::Kind::BoolValue(_)) + ) + } + 5u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(__buffa::oneof::value::Kind::StructValue(_)) + ) + } + 6u32 => { + ::core::matches!( + & self.kind, + ::core::option::Option::Some(__buffa::oneof::value::Kind::ListValue(_)) + ) + } + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Value { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Value { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Value { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Value"; @@ -859,48 +1067,100 @@ impl ::buffa::DefaultInstance for ListValue { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for ListValue { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for ListValue { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::List(&self.values), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.values.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for ListValue { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl ListValue { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for ListValue { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for ListValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "ListValue"; diff --git a/buffa-types/src/generated/google.protobuf.timestamp.rs b/buffa-types/src/generated/google.protobuf.timestamp.rs index 9001ec2..f3abe5a 100644 --- a/buffa-types/src/generated/google.protobuf.timestamp.rs +++ b/buffa-types/src/generated/google.protobuf.timestamp.rs @@ -143,48 +143,102 @@ impl ::buffa::DefaultInstance for Timestamp { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Timestamp { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Timestamp { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I64(self.seconds), + 2u32 => ::buffa_descriptor::reflect::ValueRef::I32(self.nanos), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.seconds != 0, + 2u32 => self.nanos != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Timestamp { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Timestamp { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Timestamp { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Timestamp { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Timestamp"; diff --git a/buffa-types/src/generated/google.protobuf.wrappers.rs b/buffa-types/src/generated/google.protobuf.wrappers.rs index 91585d9..0d8dacb 100644 --- a/buffa-types/src/generated/google.protobuf.wrappers.rs +++ b/buffa-types/src/generated/google.protobuf.wrappers.rs @@ -33,48 +33,100 @@ impl ::buffa::DefaultInstance for DoubleValue { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for DoubleValue { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for DoubleValue { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::F64(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0.0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for DoubleValue { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl DoubleValue { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for DoubleValue { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for DoubleValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "DoubleValue"; @@ -221,48 +273,100 @@ impl ::buffa::DefaultInstance for FloatValue { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for FloatValue { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for FloatValue { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::F32(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0.0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for FloatValue { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl FloatValue { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for FloatValue { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for FloatValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "FloatValue"; @@ -409,48 +513,100 @@ impl ::buffa::DefaultInstance for Int64Value { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Int64Value { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Int64Value { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I64(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Int64Value { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Int64Value { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Int64Value { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Int64Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Int64Value"; @@ -597,48 +753,100 @@ impl ::buffa::DefaultInstance for UInt64Value { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for UInt64Value { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for UInt64Value { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::U64(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for UInt64Value { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl UInt64Value { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for UInt64Value { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for UInt64Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "UInt64Value"; @@ -785,48 +993,100 @@ impl ::buffa::DefaultInstance for Int32Value { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for Int32Value { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for Int32Value { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::I32(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for Int32Value { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl Int32Value { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for Int32Value { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for Int32Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "Int32Value"; @@ -973,48 +1233,100 @@ impl ::buffa::DefaultInstance for UInt32Value { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for UInt32Value { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for UInt32Value { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::U32(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value != 0, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for UInt32Value { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl UInt32Value { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for UInt32Value { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for UInt32Value { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "UInt32Value"; @@ -1161,48 +1473,100 @@ impl ::buffa::DefaultInstance for BoolValue { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for BoolValue { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for BoolValue { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::Bool(self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => self.value, + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for BoolValue { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl BoolValue { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for BoolValue { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for BoolValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "BoolValue"; @@ -1349,48 +1713,100 @@ impl ::buffa::DefaultInstance for StringValue { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for StringValue { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for StringValue { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::String(&self.value), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.value.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for StringValue { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl StringValue { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for StringValue { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for StringValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "StringValue"; @@ -1540,48 +1956,100 @@ impl ::buffa::DefaultInstance for BytesValue { } } #[cfg(feature = "reflect")] -impl ::buffa_descriptor::reflect::Reflectable for BytesValue { - /// Bridge-mode reflective handle: encodes `self` and decodes - /// it into a [`DynamicMessage`](::buffa_descriptor::reflect::DynamicMessage) - /// against the package's embedded descriptor pool. - /// - /// # Performance - /// - /// One full encode/decode round-trip plus a heap allocation per - /// call. Hold onto the returned handle for repeated field reads - /// rather than calling `reflect()` per field. - /// - /// # Panics - /// - /// Panics if the embedded `FileDescriptorSet` is malformed or - /// `Self::FULL_NAME` is not registered. Both indicate codegen - /// emitted inconsistent output, not consumer misuse — except - /// when this type was re-exported from a different - /// `buffa-build` invocation, whose pool is a different - /// instance. Each `generate_reflection(true)` codegen run - /// embeds its own pool; do not mix `reflect()` calls across - /// independently-generated crates. - fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { - let pool = __buffa::reflect::descriptor_pool(); - let idx = pool - .message_index(::FULL_NAME) - .unwrap_or_else(|| { - panic!( - "type {:?} not registered in this package's descriptor pool (cross-crate reflect()?)", - < Self as ::buffa::MessageName > ::FULL_NAME, - ) - }); - ::buffa_descriptor::reflect::ReflectCow::Owned( - ::buffa::alloc::boxed::Box::new( - ::buffa_descriptor::reflect::DynamicMessage::from_message( - self, - ::buffa::alloc::sync::Arc::clone(pool), - idx, - ), +const _: () = { + impl ::buffa_descriptor::reflect::ReflectMessage for BytesValue { + fn message_descriptor(&self) -> &::buffa_descriptor::MessageDescriptor { + __buffa::reflect::descriptor_pool() + .message(Self::__buffa_reflect_message_index()) + } + fn pool( + &self, + ) -> &::buffa::alloc::sync::Arc<::buffa_descriptor::DescriptorPool> { + __buffa::reflect::descriptor_pool() + } + fn unknown_fields(&self) -> &::buffa::UnknownFields { + &self.__buffa_unknown_fields + } + fn get( + &self, + field: &::buffa_descriptor::FieldDescriptor, + ) -> ::buffa_descriptor::reflect::ValueRef<'_> { + #[allow(unused_imports)] + use ::buffa::Enumeration as _; + match field.number() { + 1u32 => ::buffa_descriptor::reflect::ValueRef::Bytes(&self.value[..]), + _ => { + ::core::debug_assert!( + false, + "field number {} is not a member of this message's reflect get()", + field.number(), + ); + ::buffa_descriptor::reflect::ValueRef::Bool(false) + } + } + } + fn has(&self, field: &::buffa_descriptor::FieldDescriptor) -> bool { + match field.number() { + 1u32 => !self.value.is_empty(), + _ => false, + } + } + fn for_each_set( + &self, + f: &mut dyn ::core::ops::FnMut( + &::buffa_descriptor::FieldDescriptor, + ::buffa_descriptor::reflect::ValueRef<'_>, ), - ) + ) { + let md = ::buffa_descriptor::reflect::ReflectMessage::message_descriptor( + self, + ); + for fd in md.fields() { + if ::buffa_descriptor::reflect::ReflectMessage::has(self, fd) { + f(fd, ::buffa_descriptor::reflect::ReflectMessage::get(self, fd)); + } + } + } + fn to_dynamic(&self) -> ::buffa_descriptor::reflect::DynamicMessage { + ::buffa_descriptor::reflect::DynamicMessage::from_message( + self, + ::buffa::alloc::sync::Arc::clone(__buffa::reflect::descriptor_pool()), + Self::__buffa_reflect_message_index(), + ) + } } -} + impl ::buffa_descriptor::reflect::ReflectElement for BytesValue { + fn as_value_ref(&self) -> ::buffa_descriptor::reflect::ValueRef<'_> { + ::buffa_descriptor::reflect::ValueRef::Message( + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self), + ) + } + } + impl BytesValue { + /// Memoized `MessageIndex` for this message type, resolved once + /// against the package's embedded descriptor pool. + #[doc(hidden)] + fn __buffa_reflect_message_index() -> ::buffa_descriptor::MessageIndex { + static IDX: ::std::sync::OnceLock<::buffa_descriptor::MessageIndex> = ::std::sync::OnceLock::new(); + *IDX + .get_or_init(|| { + __buffa::reflect::descriptor_pool() + .message_index(::FULL_NAME) + .expect( + "generated message is registered in the embedded descriptor pool", + ) + }) + } + } + impl ::buffa_descriptor::reflect::Reflectable for BytesValue { + /// Vtable-mode reflective handle: borrows `self` directly. No + /// encode/decode round-trip and no allocation — the reflective + /// accessors read this message's fields in place. + fn reflect(&self) -> ::buffa_descriptor::reflect::ReflectCow<'_> { + ::buffa_descriptor::reflect::ReflectCow::Borrowed(self) + } + } +}; impl ::buffa::MessageName for BytesValue { const PACKAGE: &'static str = "google.protobuf"; const NAME: &'static str = "BytesValue"; From df6b5125993df44d474018862ea8edc19fe05c18 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 21:54:14 +0000 Subject: [PATCH 08/12] build: public ReflectMode selector (Off / Bridge / VTable) Add a `ReflectMode` enum (buffa-codegen) and expose it as the canonical reflection selector: `buffa_build::Config::reflect_mode(ReflectMode)` and `protoc-gen-buffa`'s `reflect_mode=off|bridge|vtable` option. It maps to the underlying generate_reflection / generate_reflection_vtable config flags. `generate_reflection(bool)` stays as the bridge-or-off shorthand. The experimental, doc-hidden `buffa_build::Config::generate_reflection_vtable` method is removed in favor of `reflect_mode(VTable)`; the buffa-test, conformance, and benchmark build scripts migrate to it. Generated output is unchanged (same flags), so no regen. --- benchmarks/buffa/build.rs | 3 +- buffa-build/src/lib.rs | 29 +++++++++-------- buffa-codegen/src/lib.rs | 43 +++++++++++++++++++++++-- buffa-codegen/src/tests/reflect_view.rs | 15 +++++++++ buffa-test/build.rs | 6 ++-- conformance/build.rs | 12 +++---- protoc-gen-buffa/src/main.rs | 15 +++++++++ 7 files changed, 92 insertions(+), 31 deletions(-) diff --git a/benchmarks/buffa/build.rs b/benchmarks/buffa/build.rs index 2592be9..f392a63 100644 --- a/benchmarks/buffa/build.rs +++ b/benchmarks/buffa/build.rs @@ -7,8 +7,7 @@ fn main() { ]) .includes(&["../proto/"]) .generate_json(true) - .generate_reflection(true) - .generate_reflection_vtable(true) + .reflect_mode(buffa_build::ReflectMode::VTable) .compile() .expect("failed to compile benchmark protos"); } diff --git a/buffa-build/src/lib.rs b/buffa-build/src/lib.rs index c04d234..43aa682 100644 --- a/buffa-build/src/lib.rs +++ b/buffa-build/src/lib.rs @@ -34,6 +34,8 @@ use buffa_codegen::generated::descriptor::FileDescriptorSet; use buffa_codegen::CodeGenConfig; #[doc(inline)] +pub use buffa_codegen::ReflectMode; +#[doc(inline)] pub use buffa_codegen::StringRepr; /// How to produce a `FileDescriptorSet` from `.proto` files. @@ -330,23 +332,22 @@ impl Config { self } - /// Additionally emit vtable-mode reflection (`impl ReflectMessage` on view - /// types) on top of the bridge-mode `Reflectable` impl. + /// Select the reflection mode (the fuller form of + /// [`generate_reflection`](Self::generate_reflection)). /// - /// Requires [`generate_reflection`](Self::generate_reflection) and view - /// generation (both must be enabled — [`compile`](Self::compile) errors - /// otherwise). Vtable mode reads view struct fields directly through - /// `ReflectMessage`, with no encode/decode round-trip and no per-field - /// allocation for fields that are not read. + /// - [`ReflectMode::Off`] — no reflection (the default). + /// - [`ReflectMode::Bridge`] — `reflect()` round-trips through + /// `DynamicMessage`; equivalent to `generate_reflection(true)`. + /// - [`ReflectMode::VTable`] — `impl ReflectMessage` on owned and view + /// types, and `reflect()` borrows `self` with no round-trip. Requires + /// view generation (on by default). /// - /// **Experimental and `#[doc(hidden)]`.** This is a stopgap until the - /// public `ReflectMode` selector lands; the name and shape may change. It - /// is hidden from the rendered docs to avoid advertising an API that will - /// be superseded — internal builds use it directly. - #[doc(hidden)] + /// All non-`Off` modes require the consuming crate to depend on + /// `buffa-descriptor` with its `reflect` feature and on `std`. The call + /// site (`foo.reflect().get(fd)`) is identical across modes. #[must_use] - pub fn generate_reflection_vtable(mut self, enabled: bool) -> Self { - self.codegen_config.generate_reflection_vtable = enabled; + pub fn reflect_mode(mut self, mode: ReflectMode) -> Self { + mode.apply(&mut self.codegen_config); self } diff --git a/buffa-codegen/src/lib.rs b/buffa-codegen/src/lib.rs index 28aefca..300c045 100644 --- a/buffa-codegen/src/lib.rs +++ b/buffa-codegen/src/lib.rs @@ -230,6 +230,43 @@ impl StringRepr { } } +/// How much reflection support generated types get. +/// +/// Selected through `buffa_build`'s `reflect_mode` builder method (or the +/// `protoc-gen-buffa` `reflect_mode=` option). All modes need the consuming +/// crate to depend on `buffa-descriptor` with its `reflect` feature and on +/// `std`; the call site is `foo.reflect().get(fd)` regardless of mode. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +#[non_exhaustive] +pub enum ReflectMode { + /// No reflection impls. + #[default] + Off, + /// `Reflectable::reflect()` round-trips the message through a + /// `DynamicMessage` (encode → decode → boxed handle). Smaller generated + /// code; pays an allocation and a re-encode per `reflect()` call. + Bridge, + /// `impl ReflectMessage` directly on the owned and view types, and + /// `Reflectable::reflect()` borrows `self` with no round-trip. Larger + /// generated code; near-free reflective access. Requires view generation. + VTable, +} + +impl ReflectMode { + /// Apply this mode to a [`CodeGenConfig`] (sets `generate_reflection` / + /// `generate_reflection_vtable`). Used by the `buffa-build` and + /// `protoc-gen-buffa` front-ends. + pub fn apply(self, config: &mut CodeGenConfig) { + let (reflection, vtable) = match self { + ReflectMode::Off => (false, false), + ReflectMode::Bridge => (true, false), + ReflectMode::VTable => (true, true), + }; + config.generate_reflection = reflection; + config.generate_reflection_vtable = vtable; + } +} + /// Configuration for code generation. #[derive(Debug, Clone)] #[non_exhaustive] @@ -490,9 +527,9 @@ pub struct CodeGenConfig { /// /// Requires [`generate_reflection`](Self::generate_reflection) (the impls /// resolve against the same embedded `DescriptorPool`) and - /// [`generate_views`](Self::generate_views). Internal flag, exposed - /// experimentally through `buffa_build::Config::generate_reflection_vtable` - /// until the public `ReflectMode` surface lands. + /// [`generate_views`](Self::generate_views). Set via [`ReflectMode::VTable`] + /// — front-ends expose it as `buffa_build::Config::reflect_mode` / + /// `protoc-gen-buffa`'s `reflect_mode=vtable`. /// /// Defaults to `false`. pub generate_reflection_vtable: bool, diff --git a/buffa-codegen/src/tests/reflect_view.rs b/buffa-codegen/src/tests/reflect_view.rs index 4a43a49..fb43dfd 100644 --- a/buffa-codegen/src/tests/reflect_view.rs +++ b/buffa-codegen/src/tests/reflect_view.rs @@ -1,6 +1,21 @@ //! Vtable-mode reflection codegen: config validation and emitted impls. use super::*; +use crate::ReflectMode; + +#[test] +fn reflect_mode_maps_to_config_flags() { + let mut c = CodeGenConfig::default(); + + ReflectMode::Off.apply(&mut c); + assert!(!c.generate_reflection && !c.generate_reflection_vtable); + + ReflectMode::Bridge.apply(&mut c); + assert!(c.generate_reflection && !c.generate_reflection_vtable); + + ReflectMode::VTable.apply(&mut c); + assert!(c.generate_reflection && c.generate_reflection_vtable); +} /// A config with both bridge reflection and vtable mode enabled. fn vtable_config() -> CodeGenConfig { diff --git a/buffa-test/build.rs b/buffa-test/build.rs index d1b70cf..1f2723e 100644 --- a/buffa-test/build.rs +++ b/buffa-test/build.rs @@ -6,8 +6,7 @@ fn main() { .files(&["protos/basic.proto"]) .includes(&["protos/"]) .generate_text(true) - .generate_reflection(true) - .generate_reflection_vtable(true) + .reflect_mode(buffa_build::ReflectMode::VTable) .compile() .expect("buffa_build failed for basic.proto"); @@ -89,8 +88,7 @@ fn main() { .files(&["protos/proto2_defaults.proto"]) .includes(&["protos/"]) .generate_text(true) - .generate_reflection(true) - .generate_reflection_vtable(true) + .reflect_mode(buffa_build::ReflectMode::VTable) .compile() .expect("buffa_build failed for proto2_defaults.proto"); diff --git a/conformance/build.rs b/conformance/build.rs index 1530db0..f33af85 100644 --- a/conformance/build.rs +++ b/conformance/build.rs @@ -32,8 +32,7 @@ fn main() { .includes(&["protos/"]) .generate_json(true) .generate_text(true) - .generate_reflection(true) - .generate_reflection_vtable(true) + .reflect_mode(buffa_build::ReflectMode::VTable) .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto3.proto"); @@ -45,8 +44,7 @@ fn main() { .generate_json(true) .generate_text(true) .allow_message_set(true) - .generate_reflection(true) - .generate_reflection_vtable(true) + .reflect_mode(buffa_build::ReflectMode::VTable) .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto2.proto"); @@ -59,8 +57,7 @@ fn main() { .includes(&[&protos_dir]) .generate_json(true) .generate_text(true) - .generate_reflection(true) - .generate_reflection_vtable(true) + .reflect_mode(buffa_build::ReflectMode::VTable) .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto3_editions.proto"); @@ -72,8 +69,7 @@ fn main() { .generate_json(true) .generate_text(true) .allow_message_set(true) - .generate_reflection(true) - .generate_reflection_vtable(true) + .reflect_mode(buffa_build::ReflectMode::VTable) .gate_reflect_on_crate_feature(true) .compile() .expect("buffa_build failed for test_messages_proto2_editions.proto"); diff --git a/protoc-gen-buffa/src/main.rs b/protoc-gen-buffa/src/main.rs index cc4c337..04d7bda 100644 --- a/protoc-gen-buffa/src/main.rs +++ b/protoc-gen-buffa/src/main.rs @@ -194,6 +194,21 @@ fn parse_config(params: &str) -> Result { // accepted spelling is the negation. "with_setters" => codegen.generate_with_setters = value.trim() != "false", "reflection" => codegen.generate_reflection = value.trim() == "true", + // `reflect_mode=off|bridge|vtable` is the fuller form of + // `reflection=`. `vtable` additionally emits `impl ReflectMessage` + // on owned + view types and makes `reflect()` borrow `self`. + "reflect_mode" => match value.trim() { + "off" => buffa_codegen::ReflectMode::Off.apply(&mut codegen), + "bridge" => buffa_codegen::ReflectMode::Bridge.apply(&mut codegen), + "vtable" => buffa_codegen::ReflectMode::VTable.apply(&mut codegen), + other => { + eprintln!( + "protoc-gen-buffa: invalid reflect_mode '{}', \ + expected off, bridge, or vtable", + other + ); + } + }, "file_per_package" => codegen.file_per_package = value.trim() == "true", "extern_path" => { // value is "=" From bcaee71f14070d784ec0de19cefc2c0ed85df52b Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 21:54:50 +0000 Subject: [PATCH 09/12] docs: mark vtable reflection plan complete (owned vtable, ReflectMode, acceptance) --- docs/investigations/reflection-vtable.md | 79 +++++++++++++++--------- 1 file changed, 49 insertions(+), 30 deletions(-) diff --git a/docs/investigations/reflection-vtable.md b/docs/investigations/reflection-vtable.md index 058dab4..317e61a 100644 --- a/docs/investigations/reflection-vtable.md +++ b/docs/investigations/reflection-vtable.md @@ -360,38 +360,57 @@ will use. ## Sequencing -Step 1 (`ValueRef::List`/`Map` trait objects) has landed — see the Progress -note. The remaining work, as a sequence of self-contained PRs each within the -≤250-net-line budget: +**All steps below have landed.** The feature set the original plan called for — +view *and* owned vtable reflection, the public `ReflectMode` selector, and the +acceptance tests — is complete and conformance-validated. One unanticipated +prerequisite surfaced during implementation (WKT view reflection, step 3.5 +below). The remaining open items are noted under "Not yet done" at the end. -1. ✅ **`ValueRef::List`/`Map` trait-object refactor.** Done. `ValueRef` carries +1. ✅ **`ValueRef::List`/`Map` trait-object refactor.** `ValueRef` carries `&dyn ReflectList` / `&dyn ReflectMap`; `DynamicMessage` implements the - bridge side; conformance passes. -2. **Runtime container impls for the view types (§3).** `ReflectElement` / - `ReflectMapKey` traits plus blanket `ReflectList` / `ReflectMap` for - `RepeatedView` / `MapView`, in `buffa-descriptor`. Independent of codegen and - testable with hand-written views. Do this first — it de-risks the rest. -3. **`impl ReflectMessage for FooView<'a>` codegen + per-message `MessageIndex` - memoization (§1, §2).** The main deliverable, and the only high-risk PR. - Land it behind an internal mode flag so it merges without flipping any - default. Oneof dispatch and enum-number extraction are the tricky `get()` - arms. -4. **`ReflectMode::VTable` plumbing (§4).** `BuildConfig::reflect_mode`, the - `CodeGenConfig` field, `feature_gates`, the `protoc-gen-buffa` option, and - the vtable `Reflectable::reflect()` body (`ReflectCow::Borrowed(self)`). - Once (3) is solid. -5. **Acceptance: conformance via-vtable run + `OwnedView` entry-point test - (§5).** A `BUFFA_VIA_VTABLE` runner mode (decode_view → reflect → reflective - serialize), parallel to the existing `BUFFA_VIEW_JSON` / `BUFFA_VIA_REFLECT` - modes, plus the `OwnedView` → `&dyn ReflectMessage` test. Mostly test code; - a strong correctness gate. -6. **Owned-message vtable (optional follow-up).** `impl ReflectMessage` for the - owned struct, for the interceptor use case that holds an in-memory message - rather than wire bytes. Needs container impls for owned collections - (`Vec`), which forces the coherence resolution noted in §3: implement - `ReflectElement for Value` and drop the bespoke `impl ReflectList for - Vec`, unifying both paths. Scoped after views because views are the - zero-copy headline and owned vtable touches landed bridge code. + bridge side. +2. ✅ **Runtime container impls (§3).** `ReflectElement` / `ReflectMapKey` traits + plus generic `ReflectList` / `ReflectMap` for `RepeatedView` / `MapView` + (and, for owned vtable, `Vec` / `HashMap`), in `buffa-descriptor`. +3. ✅ **`impl ReflectMessage for FooView<'a>` codegen + memoized `MessageIndex` + (§1, §2).** Behind an internal mode flag; oneof dispatch and enum-number + extraction handled. +3.5. ✅ **WKT view reflection (unplanned prerequisite).** The conformance corpus + references well-known types, whose views live in `buffa-types` with no path + to `ReflectMessage`. Added a `reflect` feature to `buffa-types` (gated via the + new `gate_reflect_on_crate_feature` codegen flag) so WKT views/owned types + implement `ReflectMessage`. Without this, vtable mode only worked for + WKT-free protos. +4. ✅ **`ReflectMode` plumbing (§4).** Public `ReflectMode` enum + (Off/Bridge/VTable), exposed as `buffa_build::Config::reflect_mode` and + `protoc-gen-buffa`'s `reflect_mode=` option. Vtable mode emits + `impl ReflectMessage` for the view *and* the owned message and switches the + owned `Reflectable::reflect()` body to `ReflectCow::Borrowed(self)`. Default + stays `Off`/`Bridge`; flipping the default to `VTable` is deferred. +5. ✅ **Acceptance: conformance via-vtable run + `OwnedView` entry-point test + (§5).** `BUFFA_VIA_VTABLE` runner mode (decode_view → reflect → rebuild → + JSON) passes 1246 binary→JSON cases across proto2/proto3/editions with zero + failures, parallel to `BUFFA_VIEW_JSON` / `BUFFA_VIA_REFLECT`. The + `OwnedView` → `&dyn ReflectMessage` test and an owned-vtable↔bridge parity + test (every field kind) lock in correctness. +6. ✅ **Owned-message vtable (§6).** `impl ReflectMessage` for the owned struct; + `owned.reflect()` borrows `self` with no round-trip (the interceptor use + case). Required the coherence resolution noted in §3: `ReflectElement for + Value` and dropping the bespoke `impl ReflectList for Vec`. owned + `unknown_fields()` is overridden to preserve unknowns (bridge parity). + +### Not yet done + +- **`string_type != String` + repeated + vtable.** `ReflectElement` is + implemented for `String` but not `SmolStr` / `EcoString` / `CompactString`, so + a `repeated` string field generated with a non-default string repr *and* + vtable mode would fail to compile. Both knobs are experimental; documented as + a known gap on `ReflectElement`. +- **Flip the default `ReflectMode` to `VTable`.** Bridge remains the default; the + switch is a one-line change once vtable mode has soaked. +- **Benchmark numbers in the README.** The `reflect` bench gained vtable cases + (6–10× over bridge, ~4× over pure `DynamicMessage`); regenerating the README + charts through the pinned Xeon harness is outstanding. ## What this does *not* solve From 510002d1ec3639162737c229ad899d4673a7b0a2 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 21:55:41 +0000 Subject: [PATCH 10/12] docs: fix nested-backtick code span in CONTRIBUTING (markdownlint MD038) --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index aafba97..0cec31b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -61,7 +61,7 @@ The Dockerfile builds **two binaries**: one with default features (std) and one - **via-view** (`BUFFA_VIA_VIEW=1`) — binary input through `decode_view → to_owned_message → encode`, verifying owned/view decoder parity. - **view-json** (`BUFFA_VIEW_JSON=1`) — binary→JSON through `decode_view → serde_json::to_string(&view)`, verifying the generated view `Serialize` impls (and the hand-written WKT view `Serialize` impls in `buffa-types`). - **via-reflect** (`BUFFA_VIA_REFLECT=1`) — binary/JSON I/O through `DynamicMessage`'s descriptor-driven codec and reflective serde, verifying the runtime reflection codec independently of any generated type. -- **via-vtable** (`BUFFA_VIA_VTABLE=1`) — binary→JSON through `decode_view → (walk the view's vtable `ReflectMessage` surface) → DynamicMessage → to_json`, verifying the generated `impl ReflectMessage for FooView`. It reuses `DynamicMessage`'s JSON serializer (which passes the corpus cleanly under via-reflect), so any failure isolates a bug in the vtable `get`/`has`/`for_each_set` surface. Requires the conformance crate's `reflect` feature, so it is absent from the no_std binary. +- **via-vtable** (`BUFFA_VIA_VTABLE=1`) — binary→JSON: decode the view, walk its vtable `ReflectMessage` surface to rebuild a `DynamicMessage`, then serialize to JSON. Verifies the generated `impl ReflectMessage for FooView`. It reuses `DynamicMessage`'s JSON serializer (which passes the corpus cleanly under via-reflect), so any failure isolates a bug in the vtable `get`/`has`/`for_each_set` surface. Requires the conformance crate's `reflect` feature, so it is absent from the no_std binary. **Expected failures** are listed in `conformance/known_failures.txt` (std binary+JSON), `conformance/known_failures_nostd.txt` (no_std binary+JSON), `conformance/known_failures_view.txt` (via-view), `conformance/known_failures_view_json.txt` (view-json), `conformance/known_failures_reflect.txt` (via-reflect), `conformance/known_failures_view_vtable.txt` (via-vtable), and `conformance/known_failures_text.txt` (text format — shared between std and no_std; currently empty). The text list is passed via `--text_format_failure_list` since the runner validates each suite's list independently. When a previously-failing test starts passing, remove it from the relevant file; when a new test is expected to fail, add it. From 52ab20bc08ced1f1b497e3b6ec6ec16e4766d907 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 22:17:45 +0000 Subject: [PATCH 11/12] descriptor: ReflectElement for configurable string reprs (vtable) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implement ReflectElement for SmolStr / EcoString / CompactString, gated behind new buffa-descriptor features (smol_str / ecow / compact_str) that forward to buffa's. This closes the gap where a `repeated ` string field generated with string_type(SmolStr) + vtable reflection had no ReflectElement impl for its Vec elements. A trait-bound blanket (e.g. impl ReflectElement for S) is not possible: ProtoString is itself a structural blanket marker, and a trait-bound blanket collides with the scalar/Value impls under coherence (the same E0119 wall the message/enum element cases hit). So these are concrete per-type impls, one line each (AsRef -> ValueRef::String). Only the repeated case needs them — singular string fields reflect via deref regardless of repr, and map string keys/values stay String. Covered by a new vtable_string_repr test (Labels with string_type(SmolStr) + reflect_mode(VTable)). --- buffa-descriptor/Cargo.toml | 8 ++++ buffa-descriptor/src/reflect/containers.rs | 36 ++++++++++++++++-- buffa-test/Cargo.toml | 11 +++++- buffa-test/build.rs | 11 ++++++ buffa-test/protos/vtable_string_repr.proto | 13 +++++++ buffa-test/src/lib.rs | 11 ++++++ buffa-test/tests/vtable_string_repr.rs | 44 ++++++++++++++++++++++ docs/investigations/reflection-vtable.md | 5 --- 8 files changed, 129 insertions(+), 10 deletions(-) create mode 100644 buffa-test/protos/vtable_string_repr.proto create mode 100644 buffa-test/tests/vtable_string_repr.rs diff --git a/buffa-descriptor/Cargo.toml b/buffa-descriptor/Cargo.toml index e7eb85e..51926d2 100644 --- a/buffa-descriptor/Cargo.toml +++ b/buffa-descriptor/Cargo.toml @@ -43,3 +43,11 @@ text = ["buffa/text"] arbitrary = ["buffa/arbitrary", "dep:arbitrary"] ## Runtime reflection: `DescriptorPool`, edition feature resolution. reflect = [] +## `ReflectElement` impls for the configurable `string_type` representations, +## needed to reflect a `repeated ` field in vtable mode. Each forwards to +## the matching `buffa` feature so `buffa::::` resolves. A consumer +## building with `string_type(SmolStr)` + vtable reflection enables the matching +## feature here (typically via its own `reflect` feature). +smol_str = ["buffa/smol_str"] +ecow = ["buffa/ecow"] +compact_str = ["buffa/compact_str"] diff --git a/buffa-descriptor/src/reflect/containers.rs b/buffa-descriptor/src/reflect/containers.rs index c85a472..b22a0f9 100644 --- a/buffa-descriptor/src/reflect/containers.rs +++ b/buffa-descriptor/src/reflect/containers.rs @@ -61,10 +61,11 @@ use super::value::{MapKey, MapKeyRef, ReflectList, ReflectMap, Value, ValueRef}; /// derive [`Debug`] (the supertrait lets the generic container impls satisfy /// *their* `Debug` supertrait through the container's derive). /// -/// Note: the non-default `string_type` representations (`SmolStr`, -/// `EcoString`, `CompactString`) are **not** implemented here — a `repeated` -/// string field generated with one of those plus vtable mode would need a -/// matching impl. Both knobs are experimental, so this is a known gap. +/// The non-default `string_type` representations (`SmolStr`, `EcoString`, +/// `CompactString`) have impls gated behind the matching `buffa-descriptor` +/// feature (`smol_str` / `ecow` / `compact_str`), for reflecting a `repeated` +/// field of that type in vtable mode. A consumer building with both that +/// `string_type` and vtable reflection must enable the corresponding feature. pub trait ReflectElement: core::fmt::Debug { /// Borrow this element as a [`ValueRef`]. #[must_use] @@ -163,6 +164,33 @@ impl ReflectElement for Value { } } +// Configurable `string_type` representations, for reflecting a `repeated ` +// field in vtable mode. Each is gated on the matching `buffa-descriptor` feature +// (which forwards to `buffa`'s). Only the repeated case needs these: singular +// fields reflect via `&self.field` (any repr derefs to `str`), and `map` string +// keys/values always stay `String`. All reprs satisfy `AsRef`. + +#[cfg(feature = "smol_str")] +impl ReflectElement for buffa::smol_str::SmolStr { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::String(self.as_ref()) + } +} + +#[cfg(feature = "ecow")] +impl ReflectElement for buffa::ecow::EcoString { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::String(self.as_ref()) + } +} + +#[cfg(feature = "compact_str")] +impl ReflectElement for buffa::compact_str::CompactString { + fn as_value_ref(&self) -> ValueRef<'_> { + ValueRef::String(self.as_ref()) + } +} + // ── Map key impls (spec-valid key set) ────────────────────────────────────── macro_rules! impl_scalar_key { diff --git a/buffa-test/Cargo.toml b/buffa-test/Cargo.toml index 0725dde..559cb9f 100644 --- a/buffa-test/Cargo.toml +++ b/buffa-test/Cargo.toml @@ -23,7 +23,16 @@ buffa = { workspace = true, features = [ # embedded descriptor pool resolve. `json` because `basic.proto` is also # generated with `generate_text(true)` and the pool decodes the WKT # descriptors that need it. -buffa-descriptor = { workspace = true, features = ["reflect", "json", "std"] } +buffa-descriptor = { workspace = true, features = [ + "reflect", + "json", + "std", + # `ReflectElement` impls for the configurable string reprs, so a + # `repeated ` field reflects in vtable mode (vtable_string_repr test). + "smol_str", + "ecow", + "compact_str", +] } buffa-types = { workspace = true, features = ["json"] } bytes = { workspace = true } serde = { workspace = true } diff --git a/buffa-test/build.rs b/buffa-test/build.rs index 1f2723e..483a0db 100644 --- a/buffa-test/build.rs +++ b/buffa-test/build.rs @@ -10,6 +10,17 @@ fn main() { .compile() .expect("buffa_build failed for basic.proto"); + // string_type(SmolStr) + vtable: exercises `ReflectElement for SmolStr` on + // the repeated-string element path (`Vec`). Singular string fields + // reflect via deref; map string keys/values stay `String`. + buffa_build::Config::new() + .files(&["protos/vtable_string_repr.proto"]) + .includes(&["protos/"]) + .string_type(buffa_build::StringRepr::SmolStr) + .reflect_mode(buffa_build::ReflectMode::VTable) + .compile() + .expect("buffa_build failed for vtable_string_repr.proto"); + // Comprehensive proto3 semantics: implicit vs explicit presence for all // scalar types, open-enum contexts, default packing, synthetic oneofs. buffa_build::Config::new() diff --git a/buffa-test/protos/vtable_string_repr.proto b/buffa-test/protos/vtable_string_repr.proto new file mode 100644 index 0000000..b4cbfcb --- /dev/null +++ b/buffa-test/protos/vtable_string_repr.proto @@ -0,0 +1,13 @@ +syntax = "proto3"; + +package vtable_string_repr; + +// Built with `string_type(SmolStr)` + `reflect_mode(VTable)` to exercise the +// `ReflectElement for SmolStr` impl on the repeated-string element path. The +// owned `items` field is `Vec`; singular `name` is `SmolStr` (reflects +// via deref, no `ReflectElement`); the map stays `String`-keyed/valued. +message Labels { + string name = 1; + repeated string items = 2; + map attrs = 3; +} diff --git a/buffa-test/src/lib.rs b/buffa-test/src/lib.rs index 23b2911..4be7c1d 100644 --- a/buffa-test/src/lib.rs +++ b/buffa-test/src/lib.rs @@ -9,6 +9,17 @@ pub mod basic { buffa::include_proto!("basic"); } +/// `string_type(SmolStr)` + vtable reflection — exercises `ReflectElement for +/// SmolStr` on the repeated-string element path. +#[allow( + clippy::derivable_impls, + clippy::match_single_binding, + non_camel_case_types +)] +pub mod vtable_string_repr { + buffa::include_proto!("vtable_string_repr"); +} + #[allow( clippy::derivable_impls, clippy::match_single_binding, diff --git a/buffa-test/tests/vtable_string_repr.rs b/buffa-test/tests/vtable_string_repr.rs new file mode 100644 index 0000000..f86a96c --- /dev/null +++ b/buffa-test/tests/vtable_string_repr.rs @@ -0,0 +1,44 @@ +//! Vtable reflection over a message generated with `string_type(SmolStr)`. +//! +//! The repeated-string field is `Vec` in the owned struct, so its +//! reflective `get()` (`ValueRef::List(&self.items)`) relies on +//! `ReflectElement for SmolStr` in `buffa-descriptor` (feature `smol_str`). +//! Singular string fields reflect via deref regardless of the repr, and map +//! string keys/values stay `String`. + +use buffa_descriptor::reflect::{Reflectable, ValueRef}; +use buffa_test::vtable_string_repr::Labels; + +#[test] +fn smol_str_repeated_field_reflects() { + let labels = Labels { + name: "svc".into(), + items: vec!["a".into(), "bb".into(), "ccc".into()], + ..Default::default() + }; + + let r = labels.reflect(); + let md = r.message_descriptor(); + + // Singular SmolStr string (field 1) — reflects via deref. + assert!(matches!( + r.get(md.field(1).unwrap()), + ValueRef::String("svc") + )); + + // Repeated SmolStr (field 2) — the element path through ReflectElement. + let ValueRef::List(items) = r.get(md.field(2).unwrap()) else { + panic!("expected List") + }; + assert_eq!(items.len(), 3); + assert!(matches!(items.get(0), Some(ValueRef::String("a")))); + assert!(matches!(items.get(2), Some(ValueRef::String("ccc")))); + + let mut collected = Vec::new(); + items.for_each(&mut |v| { + if let ValueRef::String(s) = v { + collected.push(s.to_string()); + } + }); + assert_eq!(collected, vec!["a", "bb", "ccc"]); +} diff --git a/docs/investigations/reflection-vtable.md b/docs/investigations/reflection-vtable.md index 317e61a..0d89693 100644 --- a/docs/investigations/reflection-vtable.md +++ b/docs/investigations/reflection-vtable.md @@ -401,11 +401,6 @@ below). The remaining open items are noted under "Not yet done" at the end. ### Not yet done -- **`string_type != String` + repeated + vtable.** `ReflectElement` is - implemented for `String` but not `SmolStr` / `EcoString` / `CompactString`, so - a `repeated` string field generated with a non-default string repr *and* - vtable mode would fail to compile. Both knobs are experimental; documented as - a known gap on `ReflectElement`. - **Flip the default `ReflectMode` to `VTable`.** Bridge remains the default; the switch is a one-line change once vtable mode has soaked. - **Benchmark numbers in the README.** The `reflect` bench gained vtable cases From d0c54063ed27e54a22292f932fbd5e8fb876ff1f Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 22:30:44 +0000 Subject: [PATCH 12/12] build: default reflection to VTable; vtable no longer requires views MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit generate_reflection(true) (and protoc-gen-buffa reflection=true) now select ReflectMode::VTable — the fast path where reflect() borrows self — rather than Bridge. Bridge is opt-in via reflect_mode(ReflectMode::Bridge). Relax the codegen precondition: vtable mode required generate_views, but the owned impl ReflectMessage is self-contained, so vtable now requires only generate_reflection (for the descriptor pool). Views-off builds get owned-only vtable reflection (view impls skipped with the views) instead of an error. A new vtable_no_views test proves the owned-only path compiles and reflects. --- buffa-build/src/lib.rs | 38 ++++++++++++++++-------- buffa-codegen/src/lib.rs | 17 +++++------ buffa-codegen/src/tests/reflect_view.rs | 18 +++++++---- buffa-test/build.rs | 10 +++++++ buffa-test/protos/vtable_no_views.proto | 12 ++++++++ buffa-test/src/lib.rs | 10 +++++++ buffa-test/tests/vtable_no_views.rs | 31 +++++++++++++++++++ docs/investigations/reflection-vtable.md | 10 +++++-- protoc-gen-buffa/src/main.rs | 12 +++++++- 9 files changed, 129 insertions(+), 29 deletions(-) create mode 100644 buffa-test/protos/vtable_no_views.proto create mode 100644 buffa-test/tests/vtable_no_views.rs diff --git a/buffa-build/src/lib.rs b/buffa-build/src/lib.rs index 43aa682..6cf1410 100644 --- a/buffa-build/src/lib.rs +++ b/buffa-build/src/lib.rs @@ -272,13 +272,18 @@ impl Config { self } - /// Generate `impl Reflectable` for owned message types (default: false). + /// Enable reflection on generated types (default: off). /// - /// When enabled, each generated message gets a bridge-mode reflection - /// impl: `foo.reflect()` returns a [`ReflectCow`] wrapping a - /// [`DynamicMessage`] decoded from `foo`'s wire encoding, against a - /// lazily-built [`DescriptorPool`] embedded as `FileDescriptorSet` - /// bytes. The pool is reachable as `your_crate::your_pkg::descriptor_pool()`. + /// `generate_reflection(true)` selects [`ReflectMode::VTable`] — the fast + /// path: `foo.reflect()` borrows `foo` directly (no encode/decode + /// round-trip), and owned and view types implement `ReflectMessage`. For + /// the smaller bridge implementation (`reflect()` round-trips through a + /// [`DynamicMessage`]), use [`reflect_mode(ReflectMode::Bridge)`](Self::reflect_mode) + /// instead. `generate_reflection(false)` is [`ReflectMode::Off`]. + /// + /// Either mode embeds a lazily-built [`DescriptorPool`] (as + /// `FileDescriptorSet` bytes) reachable as + /// `your_crate::your_pkg::descriptor_pool()`. /// /// # Cargo.toml setup /// @@ -309,10 +314,10 @@ impl Config { /// /// # Performance /// - /// `reflect()` is one full encode/decode round-trip plus a heap - /// allocation. For repeated reflective access, hold onto the returned - /// handle rather than calling `reflect()` per field. The first call - /// also pays a one-time pool build cost. + /// In the default vtable mode, `reflect()` borrows `self` — no round-trip, + /// no allocation; reflective accessors read fields in place. (Bridge mode + /// instead pays one encode/decode round-trip plus a heap allocation per + /// call.) Either way the first call pays a one-time pool build cost. /// /// # Build time and binary size /// @@ -321,14 +326,23 @@ impl Config { /// crate this is one copy. For a multi-package codegen run the bytes /// duplicate per package — measurable for large proto trees. The /// serialization happens once per `compile()` call (not per package), - /// so build-time CPU does not scale with package count. + /// so build-time CPU does not scale with package count. Vtable mode also + /// emits an `impl ReflectMessage` per type, so it produces more code than + /// bridge mode. /// /// [`ReflectCow`]: https://docs.rs/buffa-descriptor/latest/buffa_descriptor/reflect/enum.ReflectCow.html /// [`DynamicMessage`]: https://docs.rs/buffa-descriptor/latest/buffa_descriptor/reflect/struct.DynamicMessage.html /// [`DescriptorPool`]: https://docs.rs/buffa-descriptor/latest/buffa_descriptor/struct.DescriptorPool.html #[must_use] pub fn generate_reflection(mut self, enabled: bool) -> Self { - self.codegen_config.generate_reflection = enabled; + // The simple on/off knob selects the fast vtable path; Bridge is opt-in + // via `reflect_mode`. + let mode = if enabled { + ReflectMode::VTable + } else { + ReflectMode::Off + }; + mode.apply(&mut self.codegen_config); self } diff --git a/buffa-codegen/src/lib.rs b/buffa-codegen/src/lib.rs index 300c045..5a2a3cb 100644 --- a/buffa-codegen/src/lib.rs +++ b/buffa-codegen/src/lib.rs @@ -732,16 +732,15 @@ pub fn generate( files_to_generate: &[String], config: &CodeGenConfig, ) -> Result, CodeGenError> { - // Vtable reflection emits `impl ReflectMessage` on view types and resolves - // against the per-package descriptor pool, so it needs both view generation - // and bridge-mode reflection (which emits that pool). Without this check the - // flag would silently emit nothing and the consumer would hit an opaque - // "FooView: ReflectMessage is not satisfied" error far from the cause. - if config.generate_reflection_vtable && (!config.generate_reflection || !config.generate_views) - { + // Vtable reflection resolves against the per-package descriptor pool, which + // is emitted by bridge-mode reflection — so it requires `generate_reflection`. + // It does NOT require views: the owned `impl ReflectMessage` is self-contained, + // so with views off, vtable mode still emits owned-message reflection (the + // view impls are simply skipped along with the views). + if config.generate_reflection_vtable && !config.generate_reflection { return Err(CodeGenError::Other( - "generate_reflection_vtable requires both generate_reflection and \ - generate_views to be enabled" + "generate_reflection_vtable requires generate_reflection to be enabled \ + (it provides the descriptor pool the reflect impls resolve against)" .into(), )); } diff --git a/buffa-codegen/src/tests/reflect_view.rs b/buffa-codegen/src/tests/reflect_view.rs index fb43dfd..8fb7145 100644 --- a/buffa-codegen/src/tests/reflect_view.rs +++ b/buffa-codegen/src/tests/reflect_view.rs @@ -78,18 +78,26 @@ fn vtable_without_reflection_is_rejected() { } #[test] -fn vtable_without_views_is_rejected() { +fn vtable_without_views_emits_owned_only() { + // Owned vtable is self-contained, so views-off + vtable is allowed: it + // emits the owned `impl ReflectMessage` but no view impls (there are no + // views). let config = CodeGenConfig { generate_reflection: true, generate_reflection_vtable: true, generate_views: false, ..Default::default() }; - let err = generate(&[msg_file()], &["vt.proto".to_string()], &config) - .expect_err("vtable without views must error"); + let files = + generate(&[msg_file()], &["vt.proto".to_string()], &config).expect("should generate"); + let content = joined(&files); assert!( - err.to_string().contains("generate_views"), - "error should name the missing prerequisite: {err}" + content.contains("impl ::buffa_descriptor::reflect::ReflectMessage for Msg"), + "owned ReflectMessage must be emitted: {content}" + ); + assert!( + !content.contains("ReflectMessage for MsgView"), + "no view impls when views are off: {content}" ); } diff --git a/buffa-test/build.rs b/buffa-test/build.rs index 483a0db..902c1ab 100644 --- a/buffa-test/build.rs +++ b/buffa-test/build.rs @@ -10,6 +10,16 @@ fn main() { .compile() .expect("buffa_build failed for basic.proto"); + // views(false) + vtable: owned-message vtable reflection is self-contained, + // so it must compile without view generation (only owned impls emitted). + buffa_build::Config::new() + .files(&["protos/vtable_no_views.proto"]) + .includes(&["protos/"]) + .generate_views(false) + .reflect_mode(buffa_build::ReflectMode::VTable) + .compile() + .expect("buffa_build failed for vtable_no_views.proto"); + // string_type(SmolStr) + vtable: exercises `ReflectElement for SmolStr` on // the repeated-string element path (`Vec`). Singular string fields // reflect via deref; map string keys/values stay `String`. diff --git a/buffa-test/protos/vtable_no_views.proto b/buffa-test/protos/vtable_no_views.proto new file mode 100644 index 0000000..aaffa08 --- /dev/null +++ b/buffa-test/protos/vtable_no_views.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; + +package vtable_no_views; + +// Built with generate_views(false) + reflect_mode(VTable): proves owned-message +// vtable reflection is self-contained and does not require view generation. Only +// the owned `impl ReflectMessage` is emitted; there are no view impls. +message Simple { + int32 id = 1; + string name = 2; + repeated string tags = 3; +} diff --git a/buffa-test/src/lib.rs b/buffa-test/src/lib.rs index 4be7c1d..7d5ba1d 100644 --- a/buffa-test/src/lib.rs +++ b/buffa-test/src/lib.rs @@ -20,6 +20,16 @@ pub mod vtable_string_repr { buffa::include_proto!("vtable_string_repr"); } +/// `generate_views(false)` + vtable reflection — owned-only vtable, no views. +#[allow( + clippy::derivable_impls, + clippy::match_single_binding, + non_camel_case_types +)] +pub mod vtable_no_views { + buffa::include_proto!("vtable_no_views"); +} + #[allow( clippy::derivable_impls, clippy::match_single_binding, diff --git a/buffa-test/tests/vtable_no_views.rs b/buffa-test/tests/vtable_no_views.rs new file mode 100644 index 0000000..ea865f2 --- /dev/null +++ b/buffa-test/tests/vtable_no_views.rs @@ -0,0 +1,31 @@ +//! Owned-message vtable reflection without view generation. +//! +//! `vtable_no_views.proto` is built with `generate_views(false)` + +//! `reflect_mode(VTable)`. The owned `impl ReflectMessage` is self-contained +//! (no view types involved), so `reflect()` borrows `self` and reads owned +//! fields directly — proving vtable mode does not require views. + +use buffa_descriptor::reflect::{ReflectCow, Reflectable, ValueRef}; +use buffa_test::vtable_no_views::Simple; + +#[test] +fn owned_vtable_reflects_without_views() { + let msg = Simple { + id: 7, + name: "x".into(), + tags: vec!["a".into(), "b".into()], + ..Default::default() + }; + + // Vtable mode: reflect() borrows self. + let r = msg.reflect(); + assert!(matches!(msg.reflect(), ReflectCow::Borrowed(_))); + + let md = r.message_descriptor(); + assert!(matches!(r.get(md.field(1).unwrap()), ValueRef::I32(7))); + assert!(matches!(r.get(md.field(2).unwrap()), ValueRef::String("x"))); + let ValueRef::List(tags) = r.get(md.field(3).unwrap()) else { + panic!("expected List") + }; + assert_eq!(tags.len(), 2); +} diff --git a/docs/investigations/reflection-vtable.md b/docs/investigations/reflection-vtable.md index 0d89693..73e1c0d 100644 --- a/docs/investigations/reflection-vtable.md +++ b/docs/investigations/reflection-vtable.md @@ -401,12 +401,18 @@ below). The remaining open items are noted under "Not yet done" at the end. ### Not yet done -- **Flip the default `ReflectMode` to `VTable`.** Bridge remains the default; the - switch is a one-line change once vtable mode has soaked. - **Benchmark numbers in the README.** The `reflect` bench gained vtable cases (6–10× over bridge, ~4× over pure `DynamicMessage`); regenerating the README charts through the pinned Xeon harness is outstanding. +### Done since + +- ✅ **`VTable` is the default reflection mode.** `generate_reflection(true)` (and + `protoc-gen-buffa`'s `reflection=true`) now select `VTable`; `Bridge` is opt-in + via `reflect_mode(ReflectMode::Bridge)`. Vtable no longer requires views — the + owned `impl ReflectMessage` is self-contained, so views-off builds get + owned-only vtable reflection rather than an error. + ## What this does *not* solve Reflection consumers whose own value model requires `'static` (e.g., a diff --git a/protoc-gen-buffa/src/main.rs b/protoc-gen-buffa/src/main.rs index 04d7bda..7e5ad1f 100644 --- a/protoc-gen-buffa/src/main.rs +++ b/protoc-gen-buffa/src/main.rs @@ -193,7 +193,17 @@ fn parse_config(params: &str) -> Result { // methods. Like `register_types`, the default is on, so the // accepted spelling is the negation. "with_setters" => codegen.generate_with_setters = value.trim() != "false", - "reflection" => codegen.generate_reflection = value.trim() == "true", + // `reflection=true` selects the fast vtable mode (same as + // `reflect_mode=vtable`); `reflect_mode=bridge` opts into the + // smaller round-trip implementation. + "reflection" => { + let mode = if value.trim() == "true" { + buffa_codegen::ReflectMode::VTable + } else { + buffa_codegen::ReflectMode::Off + }; + mode.apply(&mut codegen); + } // `reflect_mode=off|bridge|vtable` is the fuller form of // `reflection=`. `vtable` additionally emits `impl ReflectMessage` // on owned + view types and makes `reflect()` borrow `self`.