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/16] 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/16] 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/16] 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/16] 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/16] 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/16] 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/16] 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/16] 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/16] 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/16] 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/16] 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/16] 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`. From 54c157a18a34dfd49dfd49c28bd720b6ff875939 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 22:53:16 +0000 Subject: [PATCH 13/16] docs: chart vtable reflection (decode view floor + read comparison) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Regenerate the README reflection benchmarks with the vtable cases: - reflection-decode gains a `view` series (zero-copy decode_view). It is the floor — faster than the generated owned codec (+25% to +153%) because strings and bytes borrow from the input instead of being copied — and replaces the old bridge-round-trip series on this chart. - New reflection-read chart (vtable / bridge / dynamic): the interceptor workload of decoding a handle and scanning every field. vtable borrows a decoded view and runs 4-7x faster than the bridge round-trip, and ahead of pure DynamicMessage. generate.py learns the new series and chart. Charts are regenerated via the Docker bench harness on the dev host (not the pinned Xeon runner used for the cross-implementation charts), so they read as a buffa-internal comparison; this caveat is noted in the README section. --- README.md | 56 ++++++++++++++----- benchmarks/charts/generate.py | 24 ++++++-- .../charts/reflect-decode-analytics_event.svg | 28 +++++----- .../charts/reflect-decode-api_response.svg | 28 +++++----- .../reflect-decode-google_message1_proto3.svg | 18 +++--- .../charts/reflect-decode-log_record.svg | 28 +++++----- .../charts/reflect-encode-analytics_event.svg | 8 +-- .../charts/reflect-encode-api_response.svg | 8 +-- .../reflect-encode-google_message1_proto3.svg | 8 +-- .../charts/reflect-encode-log_record.svg | 18 +++--- .../charts/reflect-read-analytics_event.svg | 39 +++++++++++++ .../charts/reflect-read-api_response.svg | 39 +++++++++++++ .../reflect-read-google_message1_proto3.svg | 39 +++++++++++++ benchmarks/charts/reflect-read-log_record.svg | 39 +++++++++++++ docs/investigations/reflection-vtable.md | 12 ++-- 15 files changed, 296 insertions(+), 96 deletions(-) create mode 100644 benchmarks/charts/reflect-read-analytics_event.svg create mode 100644 benchmarks/charts/reflect-read-api_response.svg create mode 100644 benchmarks/charts/reflect-read-google_message1_proto3.svg create mode 100644 benchmarks/charts/reflect-read-log_record.svg diff --git a/README.md b/README.md index fc5c525..68acc93 100644 --- a/README.md +++ b/README.md @@ -28,7 +28,7 @@ The Rust ecosystem lacks an actively maintained, pure-Rust library that supports - **Unknown field preservation.** Round-trip fidelity for proxy and middleware use cases. -- **Runtime reflection.** `buffa-descriptor` (under the `reflect` feature) provides `DescriptorPool` and `DynamicMessage` for schema-driven encode, decode, and JSON without generated code — plus extensions, custom-option access, `Any` pack/unpack, and symbol→file lookup for gRPC server reflection. Generated types bridge into the same `ReflectMessage` trait via a derived `Reflectable` impl, so a CEL evaluator, transcoding gateway, or generic interceptor can treat typed and dynamic messages uniformly. See [Reflection](#reflection) for the cost relative to generated code. +- **Runtime reflection.** `buffa-descriptor` (under the `reflect` feature) provides `DescriptorPool` and `DynamicMessage` for schema-driven encode, decode, and JSON without generated code — plus extensions, custom-option access, `Any` pack/unpack, and symbol→file lookup for gRPC server reflection. Generated types implement the same `ReflectMessage` trait directly (vtable mode), so `foo.reflect()` borrows in place and a CEL evaluator, transcoding gateway, or generic interceptor treats typed and dynamic messages uniformly — without a re-encode round-trip. See [Reflection](#reflection) for the cost relative to generated code. - **`no_std` + `alloc`.** The core runtime works without `std`, including JSON serialization via serde. Enabling `std` adds `std::io` integration, `std::time` conversions, and thread-local JSON parse options. @@ -293,19 +293,36 @@ structs and then encoding them. ### Reflection -The reflection path (`DynamicMessage`) trades throughput for schema-agnostic processing: a CEL evaluator, a transcoding gateway, or a generic interceptor can encode, decode, and serialize messages it has no generated type for. These charts measure that genericity tax against the generated codec, on the same machine and with the same method as above. Only the four code-generated benchmark messages are covered, because reflection needs a generated type to compare against; `MediaFrame` is omitted. +Reflection lets a CEL evaluator, a transcoding gateway, or a generic interceptor encode, decode, and serialize messages it has no generated type for. buffa offers two implementations, selected with `reflect_mode`: **bridge** keeps generated code small (`foo.reflect()` re-encodes the typed message and decodes the bytes into a `DynamicMessage`), while **vtable** — the default when reflection is enabled — implements `ReflectMessage` directly on the generated types so `foo.reflect()` borrows `foo` in place, with no round-trip. Both hand out the same `&dyn ReflectMessage`, so the call site does not change between modes. -The three series: +These charts measure the genericity tax against the generated codec. Only the four code-generated benchmark messages are covered, because reflection needs a generated type to compare against; `MediaFrame` is omitted. They are regenerated through the Docker benchmark harness, but — unlike the cross-implementation charts above — on the development host rather than the pinned Xeon runner, so read them as a buffa-internal comparison (generated vs. reflect vs. view vs. vtable), not against the numbers in the sections above. -- **generated** — the typed codec `buffa-codegen` emits. Each message is a Rust struct with one field per proto field, and decode/encode are monomorphized to those fields. This is buffa's default path and the same `buffa` baseline charted under [Binary decode](#binary-decode) and [Binary encode](#binary-encode) above. +#### Decode + +- **generated** — the typed codec `buffa-codegen` emits: a Rust struct with one field per proto field, decode monomorphized to those fields. The same `buffa` baseline charted under [Binary decode](#binary-decode). - **reflect** — `DynamicMessage`: a single `BTreeMap` keyed by field number, driven entirely by a runtime `DescriptorPool`. No generated type is involved. -- **bridge round-trip** — what a generic interceptor pays *per message* to view a typed value through reflection. The codegen-derived `Reflectable` impl encodes the typed message and decodes the bytes back into a `DynamicMessage`, then hands it out as `&dyn ReflectMessage`. It is a generated encode plus a reflective decode, so it is always the slowest column. +- **view** — zero-copy `decode_view`: strings and bytes borrow from the input buffer instead of being copied into owned `String`/`Vec`, so it decodes *faster than the generated owned codec*. This is the floor every vtable reflection read builds on. ![Reflection decode — ApiResponse](benchmarks/charts/reflect-decode-api_response.svg) ![Reflection decode — LogRecord](benchmarks/charts/reflect-decode-log_record.svg) ![Reflection decode — AnalyticsEvent](benchmarks/charts/reflect-decode-analytics_event.svg) ![Reflection decode — GoogleMessage1](benchmarks/charts/reflect-decode-google_message1_proto3.svg) +#### Read + +The interceptor / field-mask workload: take a wire payload, obtain a reflective handle, and read every set field. This is where vtable mode pays off — it is dominated by the cheap zero-copy decode, so it runs several times faster than either reflection alternative. + +- **vtable** — `decode_view`, then read through the borrowed `&dyn ReflectMessage`. No round-trip, no per-field allocation. +- **bridge** — decode the owned message, then round-trip it into a `DynamicMessage` (the cost the codegen `Reflectable` paid per call before vtable mode). +- **dynamic** — decode straight into a `DynamicMessage`, no typed step (pure reflection). + +![Reflection read — ApiResponse](benchmarks/charts/reflect-read-api_response.svg) +![Reflection read — LogRecord](benchmarks/charts/reflect-read-log_record.svg) +![Reflection read — AnalyticsEvent](benchmarks/charts/reflect-read-analytics_event.svg) +![Reflection read — GoogleMessage1](benchmarks/charts/reflect-read-google_message1_proto3.svg) + +#### Encode + ![Reflection encode — ApiResponse](benchmarks/charts/reflect-encode-api_response.svg) ![Reflection encode — LogRecord](benchmarks/charts/reflect-encode-log_record.svg) ![Reflection encode — AnalyticsEvent](benchmarks/charts/reflect-encode-analytics_event.svg) @@ -313,12 +330,23 @@ The three series:
Raw decode data (MiB/s, % vs generated) -| Message | generated | reflect | bridge round-trip | +| Message | generated | reflect | view | +|---------|------:|------:|------:| +| ApiResponse | 831 | 320 (−61%) | 1,422 (+71%) | +| LogRecord | 779 | 448 (−42%) | 1,971 (+153%) | +| AnalyticsEvent | 220 | 83 (−62%) | 317 (+44%) | +| GoogleMessage1 | 1,020 | 198 (−81%) | 1,274 (+25%) | + +
+ +
Raw read data (MiB/s, decode + scan all fields, % vs bridge) + +| Message | vtable | bridge | dynamic | |---------|------:|------:|------:| -| ApiResponse | 834 | 323 (−61%) | 243 (−71%) | -| LogRecord | 742 | 447 (−40%) | 364 (−51%) | -| AnalyticsEvent | 221 | 83 (−62%) | 69 (−69%) | -| GoogleMessage1 | 1,022 | 217 (−79%) | 210 (−79%) | +| ApiResponse | 799 (+398%) | 160 | 233 (+46%) | +| LogRecord | 1,462 (+667%) | 191 | 356 (+86%) | +| AnalyticsEvent | 315 (+516%) | 51 | 83 (+62%) | +| GoogleMessage1 | 654 (+351%) | 145 | 153 (+6%) |
@@ -326,10 +354,10 @@ The three series: | Message | generated | reflect | |---------|------:|------:| -| ApiResponse | 2,562 | 685 (−73%) | -| LogRecord | 4,107 | 1,292 (−69%) | -| AnalyticsEvent | 594 | 99 (−83%) | -| GoogleMessage1 | 2,636 | 353 (−87%) | +| ApiResponse | 2,347 | 670 (−71%) | +| LogRecord | 3,689 | 1,232 (−67%) | +| AnalyticsEvent | 573 | 96 (−83%) | +| GoogleMessage1 | 2,222 | 352 (−84%) | diff --git a/benchmarks/charts/generate.py b/benchmarks/charts/generate.py index 86f8299..ee46c59 100644 --- a/benchmarks/charts/generate.py +++ b/benchmarks/charts/generate.py @@ -44,7 +44,12 @@ # Reflection comparison (buffa-only: generated codec vs DynamicMessage). "generated": "#4C78A8", "reflect": "#B279A2", + "view": "#72B7B2", "bridge round-trip": "#9D755D", + # Reflection read (from wire bytes → reflective field reads). + "vtable": "#54A24B", + "bridge": "#9D755D", + "dynamic": "#B279A2", } MESSAGES = ["ApiResponse", "LogRecord", "AnalyticsEvent", "GoogleMessage1", "MediaFrame"] @@ -220,14 +225,23 @@ def build_tables( ("Go", lambda ms, md: _get_go(go, "JsonDecode", md)), ]), ("reflect-decode", [ - ("generated", lambda ms, md: _get_reflect(reflect, md, "decode/generated")), - ("reflect", lambda ms, md: _get_reflect(reflect, md, "decode/reflect")), - ("bridge round-trip", lambda ms, md: _get_reflect(reflect, md, "reflect/bridge_round_trip")), + ("generated", lambda ms, md: _get_reflect(reflect, md, "decode/generated")), + ("reflect", lambda ms, md: _get_reflect(reflect, md, "decode/reflect")), + ("view", lambda ms, md: _get_reflect(reflect, md, "decode/view")), ]), ("reflect-encode", [ ("generated", lambda ms, md: _get_reflect(reflect, md, "encode/generated")), ("reflect", lambda ms, md: _get_reflect(reflect, md, "encode/reflect")), ]), + # From wire bytes to reflective field reads (the interceptor / field-mask + # workload): decode a handle and scan all set fields. vtable borrows a + # decoded view; bridge round-trips through DynamicMessage; dynamic decodes + # straight into DynamicMessage. + ("reflect-read", [ + ("vtable", lambda ms, md: _get_reflect(reflect, md, "reflect/vtable_read_all")), + ("bridge", lambda ms, md: _get_reflect(reflect, md, "reflect/bridge_read_all")), + ("dynamic", lambda ms, md: _get_reflect(reflect, md, "reflect/dynamic_read_all")), + ]), ]: table: dict[str, dict[str, float | None]] = {} for series_name, getter in series_defs: @@ -401,6 +415,7 @@ def generate_readme_tables(tables: dict[str, dict[str, dict[str, float | None]]] "json-decode": ("JSON decode", "buffa"), "reflect-decode": ("Reflection decode", "generated"), "reflect-encode": ("Reflection encode", "generated"), + "reflect-read": ("Reflection read (decode + scan all fields)", "bridge"), } for chart_name, table in tables.items(): @@ -466,8 +481,9 @@ def load_criterion(name: str) -> dict[str, float]: "build-encode": "Build + Binary Encode Throughput (from borrowed source data)", "json-encode": "JSON Encode Throughput", "json-decode": "JSON Decode Throughput", - "reflect-decode": "Reflection Decode Throughput (generated vs DynamicMessage)", + "reflect-decode": "Reflection Decode Throughput (generated vs DynamicMessage vs view)", "reflect-encode": "Reflection Encode Throughput (generated vs DynamicMessage)", + "reflect-read": "Reflection Read Throughput (decode + scan all fields)", } # Per-message SVGs: one file per (chart, message) so each can use its own diff --git a/benchmarks/charts/reflect-decode-analytics_event.svg b/benchmarks/charts/reflect-decode-analytics_event.svg index fd43b6c..0a5d065 100644 --- a/benchmarks/charts/reflect-decode-analytics_event.svg +++ b/benchmarks/charts/reflect-decode-analytics_event.svg @@ -9,31 +9,31 @@ .grid { stroke: #d0d7de; stroke-width: 0.5; } - Reflection Decode Throughput (generated vs DynamicMessage) — AnalyticsEvent + Reflection Decode Throughput (generated vs DynamicMessage vs view) — AnalyticsEvent generated reflect - - bridge round-trip + + view 0 - 60 + 80 - 120 + 160 - 180 + 240 - 240 + 320 - 300 + 400 MiB/s AnalyticsEvent - - 220 - - 83 - - 68 + + 220 + + 83 + + 317 diff --git a/benchmarks/charts/reflect-decode-api_response.svg b/benchmarks/charts/reflect-decode-api_response.svg index 5ceba8c..0300b57 100644 --- a/benchmarks/charts/reflect-decode-api_response.svg +++ b/benchmarks/charts/reflect-decode-api_response.svg @@ -9,31 +9,31 @@ .grid { stroke: #d0d7de; stroke-width: 0.5; } - Reflection Decode Throughput (generated vs DynamicMessage) — ApiResponse + Reflection Decode Throughput (generated vs DynamicMessage vs view) — ApiResponse generated reflect - - bridge round-trip + + view 0 - 180 + 400 - 360 + 800 - 540 + 1,200 - 720 + 1,600 - 900 + 2,000 MiB/s ApiResponse - - 833 - - 322 - - 242 + + 831 + + 320 + + 1,422 diff --git a/benchmarks/charts/reflect-decode-google_message1_proto3.svg b/benchmarks/charts/reflect-decode-google_message1_proto3.svg index 5fd3009..46e2cfa 100644 --- a/benchmarks/charts/reflect-decode-google_message1_proto3.svg +++ b/benchmarks/charts/reflect-decode-google_message1_proto3.svg @@ -9,13 +9,13 @@ .grid { stroke: #d0d7de; stroke-width: 0.5; } - Reflection Decode Throughput (generated vs DynamicMessage) — GoogleMessage1 + Reflection Decode Throughput (generated vs DynamicMessage vs view) — GoogleMessage1 generated reflect - - bridge round-trip + + view 0 @@ -30,10 +30,10 @@ 2,000 MiB/s GoogleMessage1 - - 1,021 - - 217 - - 209 + + 1,019 + + 198 + + 1,273 diff --git a/benchmarks/charts/reflect-decode-log_record.svg b/benchmarks/charts/reflect-decode-log_record.svg index 4a46c09..bf7281b 100644 --- a/benchmarks/charts/reflect-decode-log_record.svg +++ b/benchmarks/charts/reflect-decode-log_record.svg @@ -9,31 +9,31 @@ .grid { stroke: #d0d7de; stroke-width: 0.5; } - Reflection Decode Throughput (generated vs DynamicMessage) — LogRecord + Reflection Decode Throughput (generated vs DynamicMessage vs view) — LogRecord generated reflect - - bridge round-trip + + view 0 - 160 + 400 - 320 + 800 - 480 + 1,200 - 640 + 1,600 - 800 + 2,000 MiB/s LogRecord - - 741 - - 447 - - 364 + + 779 + + 448 + + 1,971 diff --git a/benchmarks/charts/reflect-encode-analytics_event.svg b/benchmarks/charts/reflect-encode-analytics_event.svg index 03f25e8..7074c2f 100644 --- a/benchmarks/charts/reflect-encode-analytics_event.svg +++ b/benchmarks/charts/reflect-encode-analytics_event.svg @@ -28,8 +28,8 @@ 600 MiB/s AnalyticsEvent - - 593 - - 98 + + 573 + + 95 diff --git a/benchmarks/charts/reflect-encode-api_response.svg b/benchmarks/charts/reflect-encode-api_response.svg index c75754e..3ba54af 100644 --- a/benchmarks/charts/reflect-encode-api_response.svg +++ b/benchmarks/charts/reflect-encode-api_response.svg @@ -28,8 +28,8 @@ 3,000 MiB/s ApiResponse - - 2,561 - - 684 + + 2,347 + + 669 diff --git a/benchmarks/charts/reflect-encode-google_message1_proto3.svg b/benchmarks/charts/reflect-encode-google_message1_proto3.svg index b44bdca..e17b8d2 100644 --- a/benchmarks/charts/reflect-encode-google_message1_proto3.svg +++ b/benchmarks/charts/reflect-encode-google_message1_proto3.svg @@ -28,8 +28,8 @@ 3,000 MiB/s GoogleMessage1 - - 2,636 - - 353 + + 2,222 + + 351 diff --git a/benchmarks/charts/reflect-encode-log_record.svg b/benchmarks/charts/reflect-encode-log_record.svg index 70b54f5..8c37c8e 100644 --- a/benchmarks/charts/reflect-encode-log_record.svg +++ b/benchmarks/charts/reflect-encode-log_record.svg @@ -17,19 +17,19 @@ 0 - 1,000 + 800 - 2,000 + 1,600 - 3,000 + 2,400 - 4,000 + 3,200 - 5,000 + 4,000 MiB/s LogRecord - - 4,106 - - 1,292 + + 3,688 + + 1,232 diff --git a/benchmarks/charts/reflect-read-analytics_event.svg b/benchmarks/charts/reflect-read-analytics_event.svg new file mode 100644 index 0000000..fbb3fa2 --- /dev/null +++ b/benchmarks/charts/reflect-read-analytics_event.svg @@ -0,0 +1,39 @@ + + + + Reflection Read Throughput (decode + scan all fields) — AnalyticsEvent + + vtable + + bridge + + dynamic + + 0 + + 80 + + 160 + + 240 + + 320 + + 400 + MiB/s + AnalyticsEvent + + 314 + + 51 + + 82 + diff --git a/benchmarks/charts/reflect-read-api_response.svg b/benchmarks/charts/reflect-read-api_response.svg new file mode 100644 index 0000000..e86fb98 --- /dev/null +++ b/benchmarks/charts/reflect-read-api_response.svg @@ -0,0 +1,39 @@ + + + + Reflection Read Throughput (decode + scan all fields) — ApiResponse + + vtable + + bridge + + dynamic + + 0 + + 160 + + 320 + + 480 + + 640 + + 800 + MiB/s + ApiResponse + + 798 + + 160 + + 233 + diff --git a/benchmarks/charts/reflect-read-google_message1_proto3.svg b/benchmarks/charts/reflect-read-google_message1_proto3.svg new file mode 100644 index 0000000..4ebd847 --- /dev/null +++ b/benchmarks/charts/reflect-read-google_message1_proto3.svg @@ -0,0 +1,39 @@ + + + + Reflection Read Throughput (decode + scan all fields) — GoogleMessage1 + + vtable + + bridge + + dynamic + + 0 + + 140 + + 280 + + 420 + + 560 + + 700 + MiB/s + GoogleMessage1 + + 654 + + 145 + + 153 + diff --git a/benchmarks/charts/reflect-read-log_record.svg b/benchmarks/charts/reflect-read-log_record.svg new file mode 100644 index 0000000..bc83983 --- /dev/null +++ b/benchmarks/charts/reflect-read-log_record.svg @@ -0,0 +1,39 @@ + + + + Reflection Read Throughput (decode + scan all fields) — LogRecord + + vtable + + bridge + + dynamic + + 0 + + 400 + + 800 + + 1,200 + + 1,600 + + 2,000 + MiB/s + LogRecord + + 1,461 + + 190 + + 355 + diff --git a/docs/investigations/reflection-vtable.md b/docs/investigations/reflection-vtable.md index 73e1c0d..4abad41 100644 --- a/docs/investigations/reflection-vtable.md +++ b/docs/investigations/reflection-vtable.md @@ -399,12 +399,6 @@ below). The remaining open items are noted under "Not yet done" at the end. Value` and dropping the bespoke `impl ReflectList for Vec`. owned `unknown_fields()` is overridden to preserve unknowns (bridge parity). -### Not yet done - -- **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 @@ -412,6 +406,12 @@ below). The remaining open items are noted under "Not yet done" at the end. 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. +- ✅ **README reflection charts regenerated.** The `reflect` bench's new cases are + charted: a `view` series on reflection-decode (zero-copy decode is the floor, + +25% to +153% over the generated owned codec) and a new reflection-read chart + (`vtable` vs `bridge` vs `dynamic` — vtable runs 4–7× faster than the bridge + round-trip). Regenerated through the Docker bench harness; see the README note + that these reflection charts run on the dev host, not the pinned Xeon runner. ## What this does *not* solve From b6a2952fea76070d5b20e004c70878c987e9cf58 Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 23:05:00 +0000 Subject: [PATCH 14/16] docs: changelog entry for vtable reflection --- CHANGELOG.md | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 19749e9..dc902db 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,42 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), ## [Unreleased] +### Added + +- **Vtable reflection mode.** Generated types now implement + `buffa_descriptor::reflect::ReflectMessage` directly — on both the owned + structs and the zero-copy view types — so `foo.reflect()` borrows `foo` in + place (`ReflectCow::Borrowed`) with no encode/decode round-trip and no + per-field allocation. This is the path a CEL evaluator, transcoding gateway, or + generic interceptor takes to read fields by descriptor; reflecting a decoded + view runs several times faster than the previous bridge round-trip. Select the + mode with the new `buffa_build::ReflectMode` enum: + + ```rust + buffa_build::Config::new() + .reflect_mode(buffa_build::ReflectMode::VTable) // or ::Bridge / ::Off + .compile()?; + ``` + + The `protoc-gen-buffa` equivalent is `reflect_mode=off|bridge|vtable`. Vtable + mode does not require view generation: with views off, only the owned + `ReflectMessage` is emitted. +- **`buffa-types` `reflect` feature.** Well-known types (`Timestamp`, + `Duration`, `Struct`/`Value`, `Any`, wrappers, …) now implement + `ReflectMessage`, so messages that embed WKTs reflect end to end. +- **`ReflectElement` for the configurable `string_type` representations** + (`SmolStr`, `EcoString`, `CompactString`), gated behind the matching + `buffa-descriptor` feature, so a `repeated ` field reflects in vtable + mode. + +### Changed + +- **`generate_reflection(true)` now selects vtable mode** (previously bridge). + The reflective API is unchanged (`foo.reflect().get(fd)`), so call sites do not + change, but generated code grows by one `impl ReflectMessage` per type. Opt + back into the smaller round-trip implementation with + `reflect_mode(ReflectMode::Bridge)`. + ## [0.6.0] - 2026-05-15 ### Added From 5b97e4af667a7003aadfff5acc47be0d482e651b Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 23:09:43 +0000 Subject: [PATCH 15/16] build: make check-nostd self-contained and match CI coverage task check-nostd hard-failed on a missing bare-metal target and only checked the buffa crate, while CI's check-nostd job also checks buffa-types and buffa-descriptor no_std. Add those two checks and have the task install the thumbv7em target itself (rustup target add is idempotent), so it runs without a separate install-targets step and catches the same regressions CI does. --- CONTRIBUTING.md | 7 ++++--- Taskfile.yml | 20 ++++++++++---------- 2 files changed, 14 insertions(+), 13 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 0cec31b..8df9b27 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -96,12 +96,13 @@ CI (`check-generated-code` job) will fail if checked-in generated code is stale. ## Cross-Target Checks -Run `task install-targets` to install the additional rustup targets needed by cross-target tasks. The targets are: +`task check-nostd` adds the bare-metal `thumbv7em-none-eabihf` target on demand (it runs `rustup target add` itself, which is idempotent), so it needs no separate setup. + +For the 32-bit tasks, run `task install-targets` first to install the additional rustup target: - `i686-unknown-linux-gnu` — 32-bit x86 Linux (for `task check-32bit` / `task test-32bit`; `test-32bit` also needs `gcc-multilib`) -- `thumbv7em-none-eabihf` — bare-metal ARM Cortex-M4 (for the second step of `task check-nostd`) -The tasks have preconditions that print a clear error if the targets are missing. +`task install-targets` also installs `thumbv7em-none-eabihf` for convenience; the `check-32bit` / `test-32bit` tasks have preconditions that print a clear error if the 32-bit target is missing. ## Continuous Integration diff --git a/Taskfile.yml b/Taskfile.yml index c581317..52f29ad 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -599,18 +599,18 @@ tasks: check-nostd: desc: >- - Check that buffa compiles in no_std + alloc configuration. - The first check uses the host target with no_std features disabled. - The second check targets a bare-metal ARM Cortex-M4 (thumbv7em) - to verify true no_std compatibility with no OS or libc. - preconditions: - - sh: rustup target list --installed | grep -q thumbv7em-none-eabihf - msg: >- - Target thumbv7em-none-eabihf is not installed. - Run 'task install-targets' to install it. - cmds: + Check that buffa, buffa-types, and buffa-descriptor compile in + no_std + alloc configuration — the same crates the CI check-nostd job + covers. The host checks disable the std-only features; the bare-metal + ARM Cortex-M4 (thumbv7em) check verifies true no_std with no OS or libc. + The bare-metal target is added on demand (rustup target add is + idempotent), so this task needs no separate install-targets step. + cmds: + - rustup target add thumbv7em-none-eabihf - cargo check -p buffa --no-default-features - cargo check -p buffa --no-default-features --target thumbv7em-none-eabihf + - cargo check -p buffa-types --no-default-features + - cargo check -p buffa-descriptor --no-default-features # ── Coverage ───────────────────────────────────────────────────────── coverage: From f840c36b787c4357e8dec2e9a3a4e54604b395fe Mon Sep 17 00:00:00 2001 From: Iain McGinniss <309153+iainmcgin@users.noreply.github.com> Date: Sat, 23 May 2026 23:10:55 +0000 Subject: [PATCH 16/16] docs: add reflection architecture section to DESIGN.md Document the reflection subsystem as Core Design Decision 11: the ReflectMessage trait surface, the DynamicMessage runtime engine and embedded descriptor pool, the bridge-vs-vtable modes (with a comparison table) and ReflectMode selector, the ReflectElement/coherence story for container elements, and where it lives / how conformance validates it. Also refresh the buffa-descriptor crate blurb, which still described reflection as a future addition. --- DESIGN.md | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/DESIGN.md b/DESIGN.md index ac5082d..98c60ff 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -69,7 +69,7 @@ Both layer on top of the generated `Message` impl via `include!()` + sibling mod ### `buffa-descriptor` — Protobuf Descriptor Types -Self-hosted Rust types for `google/protobuf/descriptor.proto` and `google/protobuf/compiler/plugin.proto`, generated by `buffa-codegen` itself. These are the types that `buffa-codegen` uses to parse protoc's `CodeGeneratorRequest`, and the foundation for future runtime reflection. +Self-hosted Rust types for `google/protobuf/descriptor.proto` and `google/protobuf/compiler/plugin.proto`, generated by `buffa-codegen` itself. These are the types that `buffa-codegen` uses to parse protoc's `CodeGeneratorRequest`. Under the `reflect` feature this crate is also the home of the runtime reflection layer — `DescriptorPool`, `DynamicMessage`, and the `ReflectMessage` trait surface (see [Core Design Decision 11](#11-reflection--bridge-and-vtable-modes)). The generated code is checked in (regenerate via `task gen-bootstrap-types`). The only runtime dependency is `buffa` — no quote/syn/prettyplease — so the crate is `no_std`-capable and dependency-light enough to depend on from the runtime without pulling in the codegen toolchain. @@ -467,6 +467,30 @@ The canonical protobuf JSON mapping is non-trivial and cannot be satisfied by pl - **Well-known types**: each has a bespoke JSON representation defined by the protobuf spec — `Timestamp` as RFC 3339, `Duration` as `"1.5s"`, `FieldMask` as `"a.b,c.d"`, `Value`/`Struct`/`ListValue` as native JSON, wrapper types as their wrapped scalar, `Any` as `{"@type": "...", ...fields}`. These require hand-written `Serialize`/`Deserialize` impls in `buffa-types`. - **Default value omission**: proto3 fields at their default value are omitted from JSON output. +### 11. Reflection — Bridge and Vtable Modes + +Reflection lets code process messages by descriptor rather than by static type — the path a CEL evaluator, a transcoding gateway, a field-mask filter, or a gRPC server-reflection endpoint takes. Buffa exposes one trait surface, `ReflectMessage`, with two sources behind it: a fully dynamic runtime engine, and reflection over generated types. + +**The common surface.** `ReflectMessage` (in `buffa-descriptor`) reads a message through its `MessageDescriptor`: `get(&FieldDescriptor) -> ValueRef`, `has(&FieldDescriptor) -> bool`, `for_each_set(...)`, `to_dynamic()`, and `unknown_fields()`. `ValueRef<'a>` is a *borrowed* field value — scalars by copy, `String(&'a str)` / `Bytes(&'a [u8])` by reference, `Message(ReflectCow<'a>)` for nested messages, and `List`/`Map` as `&dyn ReflectList` / `&dyn ReflectMap` trait objects. Because every value borrows from the message, reading a field allocates nothing. + +**The runtime engine — `DynamicMessage`.** A schema-agnostic message: a `BTreeMap` keyed by field number, plus an `Arc` and the message's `MessageIndex`. It encodes, decodes, and JSON-serializes entirely from descriptor data, with no generated type involved. Generated packages embed their own `FileDescriptorSet` bytes and expose a lazily-built (`OnceLock`) pool as `your_crate::your_pkg::descriptor_pool()`, which all reflection in that package resolves against. + +**Reflection over generated types — two modes.** Generated types implement `Reflectable`, whose `reflect()` returns a `ReflectCow<'a>` — either `Owned(Box)` or `Borrowed(&'a dyn ReflectMessage)`. Codegen emits one of two bodies, selected by `ReflectMode` (`Off` / `Bridge` / `VTable`); the call site (`foo.reflect().get(fd)`) is identical either way, so switching modes is a zero-diff change for consumers. + +| | **Bridge** | **Vtable** (default) | +|---|---|---| +| `reflect()` body | re-encode `self`, decode into a `DynamicMessage`, box it | `ReflectCow::Borrowed(self)` | +| `ReflectMessage` impl | only on `DynamicMessage` | emitted on every owned struct **and** view type | +| Per-call cost | one encode + decode + allocation | a borrow; reads fields in place | +| Generated code size | smaller | one `impl ReflectMessage` per type | +| Requires views | no | no (view impls are added when views exist; the owned impl is self-contained) | + +Vtable mode is what makes reflection cheap enough to put on a hot path: reflecting a decoded view runs several times faster than the bridge round-trip (see [Reflection](README.md#reflection)), because it reuses the zero-copy `decode_view` and never materializes a `DynamicMessage`. + +**Container elements and coherence.** `List`/`Map` values dispatch through `ReflectElement` (element → `ValueRef`) and `ReflectMapKey` (key → `MapKeyRef`), with generic `ReflectList for Vec` / `RepeatedView` and `ReflectMap` impls on top. `ReflectElement` is a *closed set of concrete impls* — scalars, `&str`/`&[u8]`, `String`/`Vec`/`Bytes`, the configurable `string_type` representations, and codegen-emitted impls for each message and closed enum — rather than a blanket `impl ReflectElement for T`, which would collide with the concrete scalar impls under Rust's coherence rules. + +**Placement and validation.** The trait surface, `DynamicMessage`, the pool, and the container impls live in `buffa-descriptor` (feature `reflect`, which requires `std` for the `OnceLock`-backed pool). Codegen lives in `buffa-codegen` — `reflect.rs` (the `Reflectable` body and embedded pool), `reflect_view.rs`, and `reflect_owned.rs`. Both the dynamic codec and the vtable surface are exercised by the conformance suite: the `via-reflect` run drives all I/O through `DynamicMessage`, and the `via-vtable` run decodes a view, walks its `ReflectMessage` surface to rebuild a `DynamicMessage`, and serializes that to JSON — isolating any bug to the generated vtable `get`/`has`/`for_each_set`. + ### Owned decode: intentional throughput trade-offs Owned decode (`Message::decode_from_slice`) benchmarks within roughly ±10% of prost in most cases. The costs are intentional and attributable to specific features: