Explicit Precision::Absent variant instead of Option<Precision>

encodings/datetime-parts/src/compute/take.rs

@@ -65,7 +65,7 @@ fn take_datetime_parts(
         .seconds()
         .statistics()
         .get(Stat::Min)
-        .map(|s| s.into_inner())
+        .into_inner()
         .unwrap_or_else(|| Scalar::primitive(0i64, Nullability::NonNullable))
         .cast(array.seconds().dtype())?;
     let taken_seconds = taken_seconds.fill_null(seconds_fill)?;
@@ -74,7 +74,7 @@ fn take_datetime_parts(
         .subseconds()
         .statistics()
         .get(Stat::Min)
-        .map(|s| s.into_inner())
+        .into_inner()
         .unwrap_or_else(|| Scalar::primitive(0i64, Nullability::NonNullable))
         .cast(array.subseconds().dtype())?;
     let taken_subseconds = taken_subseconds.fill_null(subseconds_fill)?;

encodings/sequence/src/array.rs

@@ -519,12 +519,12 @@ mod tests {
         let is_sorted = arr
             .statistics()
             .with_typed_stats_set(|s| s.get_as::<bool>(Stat::IsSorted));
-        assert_eq!(is_sorted, Some(StatPrecision::Exact(true)));
+        assert_eq!(is_sorted, StatPrecision::Exact(true));
 
         let is_strict_sorted = arr
             .statistics()
             .with_typed_stats_set(|s| s.get_as::<bool>(Stat::IsStrictSorted));
-        assert_eq!(is_strict_sorted, Some(StatPrecision::Exact(true)));
+        assert_eq!(is_strict_sorted, StatPrecision::Exact(true));
         Ok(())
     }
 
@@ -535,12 +535,12 @@ mod tests {
         let is_sorted = arr
             .statistics()
             .with_typed_stats_set(|s| s.get_as::<bool>(Stat::IsSorted));
-        assert_eq!(is_sorted, Some(StatPrecision::Exact(true)));
+        assert_eq!(is_sorted, StatPrecision::Exact(true));
 
         let is_strict_sorted = arr
             .statistics()
             .with_typed_stats_set(|s| s.get_as::<bool>(Stat::IsStrictSorted));
-        assert_eq!(is_strict_sorted, Some(StatPrecision::Exact(false)));
+        assert_eq!(is_strict_sorted, StatPrecision::Exact(false));
         Ok(())
     }
 
@@ -551,12 +551,12 @@ mod tests {
         let is_sorted = arr
             .statistics()
             .with_typed_stats_set(|s| s.get_as::<bool>(Stat::IsSorted));
-        assert_eq!(is_sorted, Some(StatPrecision::Exact(false)));
+        assert_eq!(is_sorted, StatPrecision::Exact(false));
 
         let is_strict_sorted = arr
             .statistics()
             .with_typed_stats_set(|s| s.get_as::<bool>(Stat::IsStrictSorted));
-        assert_eq!(is_strict_sorted, Some(StatPrecision::Exact(false)));
+        assert_eq!(is_strict_sorted, StatPrecision::Exact(false));
         Ok(())
     }
 
@@ -575,8 +575,8 @@ mod tests {
             .statistics()
             .with_typed_stats_set(|s| s.get_as::<bool>(Stat::IsStrictSorted));
 
-        assert_eq!(is_sorted, Some(StatPrecision::Exact(true)));
-        assert_eq!(is_strict_sorted, Some(StatPrecision::Exact(true)));
+        assert_eq!(is_sorted, StatPrecision::Exact(true));
+        assert_eq!(is_strict_sorted, StatPrecision::Exact(true));
 
         Ok(())
     }

encodings/zstd/src/zstd_buffers.rs

@@ -563,7 +563,7 @@ mod tests {
 
         let compressed = ZstdBuffers::compress(&input, 3, &LEGACY_SESSION)?;
 
-        assert!(compressed.statistics().get(Stat::Min).is_some());
+        assert!(!compressed.statistics().get(Stat::Min).is_absent());
         Ok(())
     }
 

vortex-array/public-api.lock

@@ -12072,7 +12072,7 @@ pub mod vortex_array::expr::stats
 
 pub enum vortex_array::expr::stats::IntersectionResult<T>
 
-pub vortex_array::expr::stats::IntersectionResult::None
+pub vortex_array::expr::stats::IntersectionResult::Empty
 
 pub vortex_array::expr::stats::IntersectionResult::Value(T)
 
@@ -12098,6 +12098,8 @@ impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::Interse
 
 pub enum vortex_array::expr::stats::Precision<T>
 
+pub vortex_array::expr::stats::Precision::Absent
+
 pub vortex_array::expr::stats::Precision::Exact(T)
 
 pub vortex_array::expr::stats::Precision::Inexact(T)
@@ -12110,6 +12112,10 @@ impl vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>
 
 pub fn vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>::into_scalar(self, vortex_array::dtype::DType) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
+impl<T, E> vortex_array::expr::stats::Precision<core::result::Result<T, E>>
+
+pub fn vortex_array::expr::stats::Precision<core::result::Result<T, E>>::transpose(self) -> core::result::Result<vortex_array::expr::stats::Precision<T>, E>
+
 impl<T> vortex_array::expr::stats::Precision<T> where T: core::marker::Copy
 
 pub fn vortex_array::expr::stats::Precision<T>::to_inexact(&self) -> Self
@@ -12128,19 +12134,19 @@ pub fn vortex_array::expr::stats::Precision<T>::inexact<S: core::convert::Into<T
 
 pub fn vortex_array::expr::stats::Precision<T>::into_inexact(self) -> Self
 
-pub fn vortex_array::expr::stats::Precision<T>::into_inner(self) -> T
+pub fn vortex_array::expr::stats::Precision<T>::into_inner(self) -> core::option::Option<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::is_absent(&self) -> bool
 
 pub fn vortex_array::expr::stats::Precision<T>::is_exact(&self) -> bool
 
 pub fn vortex_array::expr::stats::Precision<T>::map<U, F: core::ops::function::FnOnce(T) -> U>(self, F) -> vortex_array::expr::stats::Precision<U>
 
-pub fn vortex_array::expr::stats::Precision<T>::try_map<U, F: core::ops::function::FnOnce(T) -> vortex_error::VortexResult<U>>(self, F) -> vortex_error::VortexResult<vortex_array::expr::stats::Precision<U>>
-
 pub fn vortex_array::expr::stats::Precision<T>::zip<U>(self, vortex_array::expr::stats::Precision<U>) -> vortex_array::expr::stats::Precision<(T, U)>
 
 impl<T> vortex_array::expr::stats::Precision<T>
 
-pub fn vortex_array::expr::stats::Precision<T>::bound<S: vortex_array::expr::stats::StatType<T>>(self) -> <S as vortex_array::expr::stats::StatType>::Bound
+pub fn vortex_array::expr::stats::Precision<T>::bound<S: vortex_array::expr::stats::StatType<T>>(self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound>
 
 impl<T> vortex_array::expr::stats::Precision<core::option::Option<T>>
 
@@ -12182,6 +12188,10 @@ pub fn vortex_array::expr::stats::Precision<T>::fmt(&self, &mut core::fmt::Forma
 
 impl<T: core::marker::Copy> core::marker::Copy for vortex_array::expr::stats::Precision<T>
 
+impl<T> core::default::Default for vortex_array::expr::stats::Precision<T>
+
+pub fn vortex_array::expr::stats::Precision<T>::default() -> vortex_array::expr::stats::Precision<T>
+
 impl<T> core::marker::StructuralPartialEq for vortex_array::expr::stats::Precision<T>
 
 #[repr(u8)] pub enum vortex_array::expr::stats::Stat
@@ -12548,47 +12558,47 @@ pub const vortex_array::expr::stats::UncompressedSizeInBytes::STAT: vortex_array
 
 pub trait vortex_array::expr::stats::StatsProvider
 
-pub fn vortex_array::expr::stats::StatsProvider::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::expr::stats::StatsProvider::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
 pub fn vortex_array::expr::stats::StatsProvider::is_empty(&self) -> bool
 
 pub fn vortex_array::expr::stats::StatsProvider::len(&self) -> usize
 
 impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::MutTypedStatsSetRef<'_, '_>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
 pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
 
 pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::len(&self) -> usize
 
 impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
 pub fn vortex_array::stats::StatsSetRef<'_>::is_empty(&self) -> bool
 
 pub fn vortex_array::stats::StatsSetRef<'_>::len(&self) -> usize
 
 impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::TypedStatsSetRef<'_, '_>
 
-pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
 pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
 
 pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::len(&self) -> usize
 
 pub trait vortex_array::expr::stats::StatsProviderExt: vortex_array::expr::stats::StatsProvider
 
-pub fn vortex_array::expr::stats::StatsProviderExt::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+pub fn vortex_array::expr::stats::StatsProviderExt::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<T>
 
 pub fn vortex_array::expr::stats::StatsProviderExt::get_as_bound<S, U>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound> where S: vortex_array::expr::stats::StatType<U>, U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
 
 pub fn vortex_array::expr::stats::StatsProviderExt::get_scalar_bound<S: vortex_array::expr::stats::StatType<vortex_array::scalar::Scalar>>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound>
 
 impl<S> vortex_array::expr::stats::StatsProviderExt for S where S: vortex_array::expr::stats::StatsProvider
 
-pub fn S::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+pub fn S::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<T>
 
 pub fn S::get_as_bound<S, U>(&self) -> core::option::Option<<S as vortex_array::expr::stats::StatType>::Bound> where S: vortex_array::expr::stats::StatType<U>, U: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>
 
@@ -20228,7 +20238,7 @@ pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::merge_unordered(self, &
 
 impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::MutTypedStatsSetRef<'_, '_>
 
-pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
 pub fn vortex_array::stats::MutTypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
 
@@ -20266,9 +20276,9 @@ impl vortex_array::stats::StatsSet
 
 pub fn vortex_array::stats::StatsSet::clear(&mut self, vortex_array::expr::stats::Stat)
 
-pub fn vortex_array::stats::StatsSet::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>>
+pub fn vortex_array::stats::StatsSet::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::ScalarValue>
 
-pub fn vortex_array::stats::StatsSet::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, vortex_array::expr::stats::Stat, &vortex_array::dtype::DType) -> core::option::Option<vortex_array::expr::stats::Precision<T>>
+pub fn vortex_array::stats::StatsSet::get_as<T: for<'a> core::convert::TryFrom<&'a vortex_array::scalar::Scalar, Error = vortex_error::VortexError>>(&self, vortex_array::expr::stats::Stat, &vortex_array::dtype::DType) -> vortex_array::expr::stats::Precision<T>
 
 pub fn vortex_array::stats::StatsSet::is_empty(&self) -> bool
 
@@ -20390,7 +20400,7 @@ pub fn vortex_array::stats::StatsSetRef<'_>::with_typed_stats_set<U, F: core::op
 
 impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::StatsSetRef<'_>
 
-pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::stats::StatsSetRef<'_>::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
 pub fn vortex_array::stats::StatsSetRef<'_>::is_empty(&self) -> bool
 
@@ -20410,7 +20420,7 @@ pub vortex_array::stats::TypedStatsSetRef::values: &'a vortex_array::stats::Stat
 
 impl vortex_array::expr::stats::StatsProvider for vortex_array::stats::TypedStatsSetRef<'_, '_>
 
-pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> core::option::Option<vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>>
+pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::get(&self, vortex_array::expr::stats::Stat) -> vortex_array::expr::stats::Precision<vortex_array::scalar::Scalar>
 
 pub fn vortex_array::stats::TypedStatsSetRef<'_, '_>::is_empty(&self) -> bool
 

vortex-array/src/aggregate_fn/accumulator.rs

@@ -122,7 +122,7 @@ impl<V: AggregateFnVTable> DynAccumulator for Accumulator<V> {
         // 0. Legacy stats bridge: if this aggregate is still cached under a legacy Stat slot,
         //    consume that exact stat before kernel dispatch or decode.
         if let Some(stat) = Stat::from_aggregate_fn(&self.aggregate_fn)
-            && let Some(Precision::Exact(partial)) = batch.statistics().get(stat)
+            && let Precision::Exact(partial) = batch.statistics().get(stat)
         {
             vortex_ensure!(
                 partial.dtype() == &self.partial_dtype,

vortex-array/src/aggregate_fn/fns/is_constant/mod.rs

@@ -89,7 +89,7 @@ fn arrays_value_equal(a: &ArrayRef, b: &ArrayRef, ctx: &mut ExecutionCtx) -> Vor
 /// 5. Is all valid AND has minimum and maximum statistics that are equal.
 pub fn is_constant(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<bool> {
     // Short-circuit using cached array statistics.
-    if let Some(Precision::Exact(value)) = array.statistics().get_as::<bool>(Stat::IsConstant) {
+    if let Precision::Exact(value) = array.statistics().get_as::<bool>(Stat::IsConstant) {
         return Ok(value);
     }
 
@@ -133,14 +133,14 @@ pub fn is_constant(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<boo
     }
 
     // We already know here that the array is all valid, so we check for min/max stats.
-    let min = array.statistics().get(Stat::Min);
-    let max = array.statistics().get(Stat::Max);
+    let min_stat = array.statistics().get(Stat::Min);
+    let max_stat = array.statistics().get(Stat::Max);
 
-    if let Some((min, max)) = min.zip(max)
-        && min.is_exact()
+    if let Precision::Exact(min) = min_stat.as_ref()
+        && let Precision::Exact(max) = max_stat.as_ref()
         && min == max
         && (Stat::NaNCount.dtype(array.dtype()).is_none()
-            || array.statistics().get_as::<u64>(Stat::NaNCount) == Some(Precision::exact(0u64)))
+            || array.statistics().get_as::<u64>(Stat::NaNCount) == Precision::exact(0u64))
     {
         array
             .statistics()

vortex-array/src/aggregate_fn/fns/is_sorted/mod.rs

@@ -77,7 +77,7 @@ fn is_sorted_impl(array: &ArrayRef, strict: bool, ctx: &mut ExecutionCtx) -> Vor
     };
 
     // Short-circuit using cached array statistics.
-    if let Some(Precision::Exact(value)) = array.statistics().get_as::<bool>(stat) {
+    if let Precision::Exact(value) = array.statistics().get_as::<bool>(stat) {
         return Ok(value);
     }
 

vortex-array/src/aggregate_fn/fns/min_max/mod.rs

@@ -46,14 +46,8 @@ static NAMES: LazyLock<FieldNames> = LazyLock::new(|| FieldNames::from(["min", "
 /// This will update the stats set of the array as a side effect.
 pub fn min_max(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Option<MinMaxResult>> {
     // Short-circuit using cached array statistics.
-    let cached_min = array
-        .statistics()
-        .get(Stat::Min)
-        .and_then(Precision::as_exact);
-    let cached_max = array
-        .statistics()
-        .get(Stat::Max)
-        .and_then(Precision::as_exact);
+    let cached_min = array.statistics().get(Stat::Min).as_exact();
+    let cached_max = array.statistics().get(Stat::Max).as_exact();
     if let Some((min, max)) = cached_min.zip(cached_max) {
         let non_nullable_dtype = array.dtype().as_nonnullable();
         return Ok(Some(MinMaxResult {

vortex-array/src/aggregate_fn/fns/nan_count/mod.rs

@@ -32,7 +32,7 @@ use crate::scalar::ScalarValue;
 /// See [`NanCount`] for details.
 pub fn nan_count(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<usize> {
     // Short-circuit using cached array statistics.
-    if let Some(Precision::Exact(nan_count_scalar)) = array.statistics().get(Stat::NaNCount) {
+    if let Precision::Exact(nan_count_scalar) = array.statistics().get(Stat::NaNCount) {
         return usize::try_from(&nan_count_scalar)
             .map_err(|e| vortex_err!("Failed to convert NaN count stat to usize: {e}"));
     }

vortex-array/src/aggregate_fn/fns/null_count/mod.rs

@@ -25,7 +25,7 @@ use crate::scalar::ScalarValue;
 
 /// Return the number of null values in an array.
 pub fn null_count(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<usize> {
-    if let Some(Precision::Exact(null_count_scalar)) = array.statistics().get(Stat::NullCount) {
+    if let Precision::Exact(null_count_scalar) = array.statistics().get(Stat::NullCount) {
         return usize::try_from(&null_count_scalar)
             .map_err(|e| vortex_err!("Failed to convert null count stat to usize: {e}"));
     }
@@ -170,7 +170,7 @@ mod tests {
         assert_eq!(null_count(&array, &mut ctx)?, 2);
         assert_eq!(
             array.statistics().get_as::<u64>(Stat::NullCount),
-            Some(Precision::exact(2u64))
+            Precision::exact(2u64)
         );
         Ok(())
     }

vortex-array/src/aggregate_fn/fns/sum/mod.rs

@@ -41,7 +41,7 @@ use crate::scalar::Scalar;
 /// See [`Sum`] for details.
 pub fn sum(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<Scalar> {
     // Short-circuit using cached array statistics.
-    if let Some(Precision::Exact(sum_scalar)) = array.statistics().get(Stat::Sum) {
+    if let Precision::Exact(sum_scalar) = array.statistics().get(Stat::Sum) {
         return Ok(sum_scalar);
     }
 
@@ -379,7 +379,7 @@ mod tests {
 
         // For non-float types, try statistics short-circuit with accumulator.
         if !matches!(&sum_dtype, DType::Primitive(p, _) if p.is_float())
-            && let Some(Precision::Exact(sum_scalar)) = array.statistics().get(Stat::Sum)
+            && let Precision::Exact(sum_scalar) = array.statistics().get(Stat::Sum)
         {
             return add_scalars(&sum_dtype, &sum_scalar, accumulator);
         }

vortex-array/src/aggregate_fn/fns/uncompressed_size_in_bytes/mod.rs

@@ -63,9 +63,7 @@ pub fn uncompressed_size_in_bytes(array: &ArrayRef, ctx: &mut ExecutionCtx) -> V
 }
 
 fn uncompressed_size_in_bytes_u64(array: &ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult<u64> {
-    if let Some(Precision::Exact(size_scalar)) =
-        array.statistics().get(Stat::UncompressedSizeInBytes)
-    {
+    if let Precision::Exact(size_scalar) = array.statistics().get(Stat::UncompressedSizeInBytes) {
         return u64::try_from(&size_scalar)
             .map_err(|e| vortex_err!("Failed to convert uncompressed size stat to u64: {e}"));
     }
@@ -597,7 +595,7 @@ mod tests {
 
         assert_eq!(
             array.statistics().get(Stat::UncompressedSizeInBytes),
-            Some(Precision::exact(u64::try_from(size)?))
+            Precision::exact(u64::try_from(size)?)
         );
         Ok(())
     }