Add per-stroke random seed values for use with BrushBehavior::NoiseNode

Ink Open Source · copybara-github · commit ded3938dcdd4 · 2025-01-29T10:37:03.000-08:00
This CL allows supplying `InProgressStroke` with a `stroke_seed` value that is used to help seed the random number generators for `NoiseNode`s in the brush, if any.  These means that two strokes with the same randomized brush will (in general) use different random values.

To prevent existing strokes from changing when serialized or regenerated, we must also persist that each dry stroke's seed somehow.  The most expedient places to keep it are within the `Brush` or in the `StrokeInputBatch` (since our API is built to assume that these two things combined are sufficient to regenerate a stroke).  This CL opts to store this value in the `StrokeInputBatch`, since that's the component that already varies from stroke to stroke.

PiperOrigin-RevId: 718365728
diff --git a/ink/storage/proto/coded.proto b/ink/storage/proto/coded.proto
@@ -110,6 +110,10 @@ message CodedStrokeInputBatch {
   // A missing or zero value indicates that the relationship between stroke
   // space and physical space is unknown or ill-defined for this input batch.
   optional float stroke_unit_length_in_centimeters = 8;
+
+  // The seed value that should be used for seeding any noise generators for
+  // brush behaviors when a full stroke is regenerated with this input batch.
+  optional fixed32 noise_seed = 9;
 }
 
 // A 2D mesh; compressed lossily using delta coding.
diff --git a/ink/storage/stroke_input_batch.cc b/ink/storage/stroke_input_batch.cc
@@ -67,6 +67,7 @@ void EncodeStrokeInputBatch(const StrokeInputBatch& input_batch,
                             CodedStrokeInputBatch& input_proto) {
   if (input_batch.Size() == 0) {
     input_proto.Clear();
+    input_proto.set_noise_seed(input_batch.GetNoiseSeed());
     return;
   }
   // Determine the envelope for the input positions and the maximum input time
@@ -236,6 +237,7 @@ void EncodeStrokeInputBatch(const StrokeInputBatch& input_batch,
     input_proto.set_stroke_unit_length_in_centimeters(
         stroke_unit_length->ToCentimeters());
   }
+  input_proto.set_noise_seed(input_batch.GetNoiseSeed());
 }
 
 namespace {
@@ -296,6 +298,7 @@ absl::StatusOr<StrokeInputBatch> DecodeStrokeInputBatch(
       return status;
     }
   }
+  batch.SetNoiseSeed(input_proto.noise_seed());
   return batch;
 }
 
diff --git a/ink/storage/stroke_input_batch_test.cc b/ink/storage/stroke_input_batch_test.cc
@@ -219,6 +219,15 @@ TEST_F(StrokeInputBatchTest, EncodeEmptyInputs) {
   EXPECT_FALSE(input_proto.has_x_stroke_space());
 }
 
+TEST_F(StrokeInputBatchTest, EncodeEmptyInputsWithNoiseSeed) {
+  CodedStrokeInputBatch input_proto;
+  StrokeInputBatch empty_input_batch;
+  empty_input_batch.SetNoiseSeed(12345);
+  EncodeStrokeInputBatch(empty_input_batch, input_proto);
+  EXPECT_FALSE(input_proto.has_x_stroke_space());
+  EXPECT_EQ(input_proto.noise_seed(), 12345);
+}
+
 TEST_F(StrokeInputBatchTest, EncodeSingleInputPosition) {
   // Create a stroke with a single input point.
   absl::StatusOr<StrokeInputBatch> single_input_batch =
@@ -382,7 +391,10 @@ void StrokeInputBatchRoundTrip(const StrokeInputBatch& inputs) {
   absl::StatusOr<StrokeInputBatch> decoded = DecodeStrokeInputBatch(proto);
   ASSERT_EQ(decoded.status(), absl::OkStatus());
   // Because of quantization, the decoded batch is not guaranteed to exactly
-  // match the original.
+  // match the original.  However, some data should match exactly:
+  EXPECT_EQ(decoded->GetToolType(), inputs.GetToolType());
+  EXPECT_EQ(decoded->GetStrokeUnitLength(), inputs.GetStrokeUnitLength());
+  EXPECT_EQ(decoded->GetNoiseSeed(), inputs.GetNoiseSeed());
 }
 FUZZ_TEST(StrokeInputBatchFuzzTest, StrokeInputBatchRoundTrip)
     // TODO: b/349965543 - Currently, extreme input position values sometimes
diff --git a/ink/strokes/in_progress_stroke.cc b/ink/strokes/in_progress_stroke.cc
@@ -56,9 +56,10 @@ void InProgressStroke::Clear() {
   inputs_are_finished_ = true;
 }
 
-void InProgressStroke::Start(const Brush& brush) {
+void InProgressStroke::Start(const Brush& brush, uint32_t noise_seed) {
   Clear();
   brush_ = brush;
+  processed_inputs_.SetNoiseSeed(noise_seed);
   inputs_are_finished_ = false;
 
   absl::Span<const BrushCoat> coats = brush_->GetCoats();
@@ -72,7 +73,7 @@ void InProgressStroke::Start(const Brush& brush) {
   for (uint32_t i = 0; i < num_coats; ++i) {
     shape_builders_[i].StartStroke(brush_->GetFamily().GetInputModel(),
                                    coats[i], brush_->GetSize(),
-                                   brush_->GetEpsilon());
+                                   brush_->GetEpsilon(), noise_seed);
   }
 }
 
diff --git a/ink/strokes/in_progress_stroke.h b/ink/strokes/in_progress_stroke.h
@@ -96,7 +96,7 @@ class InProgressStroke {
   // This includes clearing or resetting any existing inputs, mesh data, and
   // updated region. This method must be called at least once after construction
   // before starting to call `EnqueueInputs()` or `UpdateShape()`.
-  void Start(const Brush& brush);
+  void Start(const Brush& brush, uint32_t noise_seed = 0);
 
   // Enqueues the incremental `real_inputs` and sets the prediction to
   // `predicted_inputs`, overwriting any previous prediction. Queued inputs will
diff --git a/ink/strokes/input/fuzz_domains.cc b/ink/strokes/input/fuzz_domains.cc
@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <cstddef>
+#include <cstdint>
 #include <optional>
 #include <utility>
 #include <vector>
@@ -82,7 +83,7 @@ fuzztest::Domain<StrokeInputBatch> StrokeInputBatchWithPositionsAndMinSize(
       [](const std::vector<std::pair<Point, Duration32>>& xyts) {
         return fuzztest::Map(
             [xyts](StrokeInput::ToolType tool_type,
-                   PhysicalDistance stroke_unit_length,
+                   PhysicalDistance stroke_unit_length, uint32_t noise_seed,
                    const std::optional<std::vector<float>>& pressures,
                    const std::optional<std::vector<Angle>>& tilts,
                    const std::optional<std::vector<Angle>>& orientations) {
@@ -104,11 +105,12 @@ fuzztest::Domain<StrokeInputBatch> StrokeInputBatchWithPositionsAndMinSize(
                                        : StrokeInput::kNoOrientation,
                 });
               }
-              return StrokeInputBatch::Create(inputs).value();
+              return StrokeInputBatch::Create(inputs, noise_seed).value();
             },
             ArbitraryToolType(),
             fuzztest::OneOf(fuzztest::Just(StrokeInput::kNoStrokeUnitLength),
                             ValidStrokeUnitLength()),
+            fuzztest::Arbitrary<uint32_t>(),
             fuzztest::OptionalOf(
                 fuzztest::VectorOf(ValidPressure()).WithSize(xyts.size())),
             fuzztest::OptionalOf(
diff --git a/ink/strokes/input/stroke_input_batch.cc b/ink/strokes/input/stroke_input_batch.cc
@@ -17,11 +17,13 @@
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <string>
 #include <vector>
 
 #include "absl/log/absl_check.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/substitute.h"
@@ -71,6 +73,7 @@ void StrokeInputBatch::Clear() {
   size_ = 0;
   tool_type_ = StrokeInput::ToolType::kUnknown;
   stroke_unit_length_ = StrokeInput::kNoStrokeUnitLength;
+  noise_seed_ = 0;
   has_pressure_ = false;
   has_tilt_ = false;
   has_orientation_ = false;
@@ -312,7 +315,7 @@ absl::Status StrokeInputBatch::Append(absl::Span<const StrokeInput> inputs) {
 }
 
 absl::StatusOr<StrokeInputBatch> StrokeInputBatch::Create(
-    absl::Span<const StrokeInput> inputs) {
+    absl::Span<const StrokeInput> inputs, uint32_t noise_seed) {
   StrokeInputBatch batch;
 
   if (!inputs.empty()) {
@@ -323,6 +326,7 @@ absl::StatusOr<StrokeInputBatch> StrokeInputBatch::Create(
     }
   }
 
+  batch.SetNoiseSeed(noise_seed);
   return batch;
 }
 
diff --git a/ink/strokes/input/stroke_input_batch.h b/ink/strokes/input/stroke_input_batch.h
@@ -16,6 +16,7 @@
 #define INK_STROKES_INPUT_STROKE_INPUT_BATCH_H_
 
 #include <cstddef>
+#include <cstdint>
 #include <iterator>
 #include <limits>
 #include <optional>
@@ -73,7 +74,7 @@ class StrokeInputBatch {
 
   // Performs validation on `inputs` and returns the resulting batch or error.
   static absl::StatusOr<StrokeInputBatch> Create(
-      absl::Span<const StrokeInput> inputs);
+      absl::Span<const StrokeInput> inputs, uint32_t noise_seed = 0);
 
   StrokeInputBatch() = default;
   StrokeInputBatch(const StrokeInputBatch&) = default;
@@ -111,7 +112,9 @@ class StrokeInputBatch {
   // Returns an error and does not modify the batch if validation fails.
   absl::Status Append(const StrokeInput& input);
 
-  // Validates and appends a sequence of `inputs`.
+  // Validates and appends a sequence of `inputs`. This batch's per-stroke seed
+  // value is left unchanged, even when appending another batch with a different
+  // seed value.
   //
   // Returns an error and does not modify the batch if validation fails.
   absl::Status Append(absl::Span<const StrokeInput> inputs);
@@ -147,6 +150,16 @@ class StrokeInputBatch {
   bool HasTilt() const;
   bool HasOrientation() const;
 
+  // Returns the seed value that should be used for seeding any noise generators
+  // for brush behaviors when a full stroke is regenerated with this input
+  // batch. If no seed value has yet been set for this input batch, returns the
+  // default seed of zero.
+  uint32_t GetNoiseSeed() const;
+
+  // Sets the per-stroke seed value that should be used when regenerating a
+  // stroke from this input batch.
+  void SetNoiseSeed(uint32_t seed);
+
   // Which properties of the stroke should be preserved over transforms.
   enum class TransformInvariant {
     kPreserveDuration = 0,
@@ -222,6 +235,7 @@ class StrokeInputBatch {
   size_t size_ = 0;
   StrokeInput::ToolType tool_type_ = StrokeInput::ToolType::kUnknown;
   PhysicalDistance stroke_unit_length_ = StrokeInput::kNoStrokeUnitLength;
+  uint32_t noise_seed_ = 0;
   bool has_pressure_ = false;
   bool has_tilt_ = false;
   bool has_orientation_ = false;
@@ -308,6 +322,12 @@ inline std::optional<PhysicalDistance> StrokeInputBatch::GetStrokeUnitLength()
   return stroke_unit_length_;
 }
 
+inline uint32_t StrokeInputBatch::GetNoiseSeed() const { return noise_seed_; }
+
+inline void StrokeInputBatch::SetNoiseSeed(uint32_t seed) {
+  noise_seed_ = seed;
+}
+
 inline bool StrokeInputBatch::HasStrokeUnitLength() const {
   return stroke_unit_length_ != StrokeInput::kNoStrokeUnitLength;
 }
diff --git a/ink/strokes/input/stroke_input_batch_test.cc b/ink/strokes/input/stroke_input_batch_test.cc
@@ -323,7 +323,7 @@ TEST(StrokeInputBatchTest, SetReplacingLastValueOfMany) {
 TEST(StrokeInputBatchTest, Clear) {
   std::vector<StrokeInput> input_vector = MakeValidTestInputSequence();
   absl::StatusOr<StrokeInputBatch> batch =
-      StrokeInputBatch::Create(input_vector);
+      StrokeInputBatch::Create(input_vector, /*noise_seed=*/12345);
   ASSERT_EQ(batch.status(), absl::OkStatus());
 
   ASSERT_FALSE(batch->IsEmpty());
@@ -332,6 +332,7 @@ TEST(StrokeInputBatchTest, Clear) {
   ASSERT_TRUE(batch->HasTilt());
   ASSERT_TRUE(batch->HasOrientation());
   ASSERT_EQ(batch->GetToolType(), StrokeInput::ToolType::kStylus);
+  EXPECT_EQ(batch->GetNoiseSeed(), 12345u);
 
   batch->Clear();
   // Batch should now be empty and the tool type should be unknown.
@@ -341,6 +342,7 @@ TEST(StrokeInputBatchTest, Clear) {
   ASSERT_FALSE(batch->HasTilt());
   ASSERT_FALSE(batch->HasOrientation());
   EXPECT_EQ(batch->GetToolType(), StrokeInput::ToolType::kUnknown);
+  EXPECT_EQ(batch->GetNoiseSeed(), 0u);
 }
 
 TEST(StrokeInputBatchTest, AppendAfterClear) {
diff --git a/ink/strokes/input/type_matchers.cc b/ink/strokes/input/type_matchers.cc
@@ -80,7 +80,8 @@ MATCHER_P(StrokeInputBatchEqMatcher, expected, "") {
     }
   }
 
-  return true;
+  return ExplainMatchResult(Eq(expected.GetNoiseSeed()), arg.GetNoiseSeed(),
+                            result_listener);
 }
 
 }  // namespace
diff --git a/ink/strokes/internal/brush_tip_modeler.cc b/ink/strokes/internal/brush_tip_modeler.cc
@@ -274,13 +274,14 @@ Duration32 TimeSinceLastInput(
 }  // namespace
 
 void BrushTipModeler::StartStroke(absl::Nonnull<const BrushTip*> brush_tip,
-                                  float brush_size) {
+                                  float brush_size, uint32_t noise_seed) {
   ABSL_CHECK_NE(brush_tip, nullptr);
   ABSL_CHECK(std::isfinite(brush_size));
   ABSL_CHECK_GT(brush_size, 0);
 
   brush_tip_ = brush_tip;
   brush_size_ = brush_size;
+  noise_seed_ = noise_seed;
 
   // These fields will be updated as the stroke progresses.
   input_index_for_next_fixed_state_ = 0;
@@ -344,10 +345,9 @@ void BrushTipModeler::AppendBehaviorNode(const BrushBehavior::NoiseNode& node) {
       .vary_over = node.vary_over,
       .base_period = node.base_period,
   });
-  // TODO: b/373649344 - Concatenate the 32-bit per-stroke seed (once that
-  // exists) with the 32-bit node seed to form the 64-bit noise generator seed.
-  uint64_t noise_seed = node.seed;
-  current_noise_generators_.emplace_back(noise_seed);
+  uint64_t combined_seed = (static_cast<uint64_t>(noise_seed_) << 32) |
+                           static_cast<uint64_t>(node.seed);
+  current_noise_generators_.emplace_back(combined_seed);
   fixed_noise_generators_.push_back(current_noise_generators_.back());
 }
 
diff --git a/ink/strokes/internal/brush_tip_modeler.h b/ink/strokes/internal/brush_tip_modeler.h
@@ -16,6 +16,7 @@
 #define INK_STROKES_INTERNAL_BRUSH_TIP_MODELER_H_
 
 #include <cstddef>
+#include <cstdint>
 #include <optional>
 #include <vector>
 
@@ -79,7 +80,8 @@ class BrushTipModeler {
   // Calling `StartStroke()` is required before calling `UpdateStroke()`. The
   // `brush_tip` parameter must not be `nullptr` and must remain valid for the
   // duration of the stroke. `brush_size` must be finite and greater than 0.
-  void StartStroke(absl::Nonnull<const BrushTip*> brush_tip, float brush_size);
+  void StartStroke(absl::Nonnull<const BrushTip*> brush_tip, float brush_size,
+                   uint32_t noise_seed = 0);
 
   // Updates the tip modeler with the current `StrokeInputModeler::State` and
   // current inputs.
@@ -176,6 +178,10 @@ class BrushTipModeler {
 
   absl::Nullable<const BrushTip*> brush_tip_ = nullptr;
   float brush_size_ = 0;
+  // Per-stroke random seed value for seeding generators for noise behaviors (if
+  // the brush tip has any). All tips/coats in the same brush use the same
+  // per-stroke seed for a given stroke.
+  uint32_t noise_seed_ = 0;
 
   // Cached values from `brush_tip_` that give the upper bounds on distance and
   // time remaining that are affected by the tip's behaviors.
diff --git a/ink/strokes/internal/jni/in_progress_stroke_jni.cc b/ink/strokes/internal/jni/in_progress_stroke_jni.cc
@@ -103,11 +103,12 @@ JNI_METHOD(strokes, InProgressStroke, void, nativeClear)
 
 // Starts the stroke with a brush.
 JNI_METHOD(strokes, InProgressStroke, void, nativeStart)
-(JNIEnv* env, jobject thiz, jlong native_pointer, jlong brush_native_pointer) {
+(JNIEnv* env, jobject thiz, jlong native_pointer, jlong brush_native_pointer,
+ jint noise_seed) {
   InProgressStroke& in_progress_stroke =
       GetInProgressStrokeWrapper(native_pointer)->in_progress_stroke;
   const Brush& brush = CastToBrush(brush_native_pointer);
-  in_progress_stroke.Start(brush);
+  in_progress_stroke.Start(brush, noise_seed);
 }
 
 JNI_METHOD(strokes, InProgressStroke, jstring, nativeEnqueueInputs)
diff --git a/ink/strokes/internal/jni/stroke_input_batch_jni.cc b/ink/strokes/internal/jni/stroke_input_batch_jni.cc
@@ -117,6 +117,13 @@ STROKE_INPUT_BATCH_JNI_METHOD(jboolean, hasOrientation)
   return batch.HasOrientation();
 }
 
+STROKE_INPUT_BATCH_JNI_METHOD(jint, getNoiseSeed)
+(JNIEnv* env, jobject thiz, jlong native_pointer) {
+  const ink::StrokeInputBatch& batch =
+      ink::CastToStrokeInputBatch(native_pointer);
+  return batch.GetNoiseSeed();
+}
+
 // ************ Native Implementation of MutableStrokeInputBatch ************
 MUTABLE_STROKE_INPUT_BATCH_JNI_METHOD(jstring, appendSingle)
 (JNIEnv* env, jobject thiz, jlong native_pointer, jint tool_type, jfloat x,
@@ -170,4 +177,11 @@ MUTABLE_STROKE_INPUT_BATCH_JNI_METHOD(jlong, copy)
   return reinterpret_cast<jlong>(new ink::StrokeInputBatch(*batch));
 }
 
+MUTABLE_STROKE_INPUT_BATCH_JNI_METHOD(void, setNoiseSeed)
+(JNIEnv* env, jobject thiz, jlong native_pointer, jint seed) {
+  ink::StrokeInputBatch* batch =
+      ink::CastToMutableStrokeInputBatch(native_pointer);
+  batch->SetNoiseSeed(seed);
+}
+
 }  // extern "C"
diff --git a/ink/strokes/internal/stroke_shape_builder.cc b/ink/strokes/internal/stroke_shape_builder.cc
@@ -43,7 +43,7 @@ bool IsWindingTextureCoat(const BrushCoat& coat) {
 
 void StrokeShapeBuilder::StartStroke(const BrushFamily::InputModel& input_model,
                                      const BrushCoat& coat, float brush_size,
-                                     float brush_epsilon) {
+                                     float brush_epsilon, uint32_t noise_seed) {
   // The `input_modeler_`, `tip_modeler_` and `tip_extruder_` CHECK-validate
   // `brush_tip` being not null, and `brush_size` and `brush_epsilon` being
   // greater than zero.
@@ -74,7 +74,7 @@ void StrokeShapeBuilder::StartStroke(const BrushFamily::InputModel& input_model,
         is_winding_texture_brush &&
         (coat.tips[i].particle_gap_distance_scale != 0 ||
          coat.tips[i].particle_gap_duration != Duration32::Zero());
-    tips_[i].modeler.StartStroke(&coat.tips[i], brush_size);
+    tips_[i].modeler.StartStroke(&coat.tips[i], brush_size, noise_seed);
     // TODO: b/285594469 - Once it's possible for there to be more than one tip,
     // this will need to be more careful about how the various extruders append
     // onto the same mesh.
diff --git a/ink/strokes/internal/stroke_shape_builder.h b/ink/strokes/internal/stroke_shape_builder.h
@@ -68,8 +68,8 @@ class StrokeShapeBuilder {
   // For now, `coat` must contain exactly one brush tip.
   // TODO: b/285594469 - Lift this restriction.
   void StartStroke(const BrushFamily::InputModel& input_model,
-                   const BrushCoat& coat, float brush_size,
-                   float brush_epsilon);
+                   const BrushCoat& coat, float brush_size, float brush_epsilon,
+                   uint32_t noise_seed = 0);
 
   // Adds new incremental real and predicted inputs to the current stroke.
   //
diff --git a/ink/strokes/stroke.cc b/ink/strokes/stroke.cc

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,7 @@ void EncodeStrokeInputBatch(const StrokeInputBatch& input_batch,`
`67`	`67`	`CodedStrokeInputBatch& input_proto) {`
`68`	`68`	`if (input_batch.Size() == 0) {`
`69`	`69`	`input_proto.Clear();`
	`70`	`+ input_proto.set_noise_seed(input_batch.GetNoiseSeed());`
`70`	`71`	`return;`
`71`	`72`	`}`
`72`	`73`	`// Determine the envelope for the input positions and the maximum input time`
`@@ -236,6 +237,7 @@ void EncodeStrokeInputBatch(const StrokeInputBatch& input_batch,`
`236`	`237`	`input_proto.set_stroke_unit_length_in_centimeters(`
`237`	`238`	`stroke_unit_length->ToCentimeters());`
`238`	`239`	`}`
	`240`	`+ input_proto.set_noise_seed(input_batch.GetNoiseSeed());`
`239`	`241`	`}`
`240`	`242`
`241`	`243`	`namespace {`
`@@ -296,6 +298,7 @@ absl::StatusOr<StrokeInputBatch> DecodeStrokeInputBatch(`
`296`	`298`	`return status;`
`297`	`299`	`}`
`298`	`300`	`}`
	`301`	`+ batch.SetNoiseSeed(input_proto.noise_seed());`
`299`	`302`	`return batch;`
`300`	`303`	`}`
`301`	`304`
Original file line number	Diff line number	Diff line change
`@@ -56,9 +56,10 @@ void InProgressStroke::Clear() {`
`56`	`56`	`inputs_are_finished_ = true;`
`57`	`57`	`}`
`58`	`58`
`59`		`-void InProgressStroke::Start(const Brush& brush) {`
	`59`	`+void InProgressStroke::Start(const Brush& brush, uint32_t noise_seed) {`
`60`	`60`	`Clear();`
`61`	`61`	`brush_ = brush;`
	`62`	`+ processed_inputs_.SetNoiseSeed(noise_seed);`
`62`	`63`	`inputs_are_finished_ = false;`
`63`	`64`
`64`	`65`	`absl::Span<const BrushCoat> coats = brush_->GetCoats();`
`@@ -72,7 +73,7 @@ void InProgressStroke::Start(const Brush& brush) {`
`72`	`73`	`for (uint32_t i = 0; i < num_coats; ++i) {`
`73`	`74`	`shape_builders_[i].StartStroke(brush_->GetFamily().GetInputModel(),`
`74`	`75`	`coats[i], brush_->GetSize(),`
`75`		`- brush_->GetEpsilon());`
	`76`	`+ brush_->GetEpsilon(), noise_seed);`
`76`	`77`	`}`
`77`	`78`	`}`
`78`	`79`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,8 @@ MATCHER_P(StrokeInputBatchEqMatcher, expected, "") {`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`		`- return true;`
	`83`	`+ return ExplainMatchResult(Eq(expected.GetNoiseSeed()), arg.GetNoiseSeed(),`
	`84`	`+ result_listener);`
`84`	`85`	`}`
`85`	`86`
`86`	`87`	`} // namespace`