From a37c12d95eca78f4fbaf246b539d789e59758c21 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Sun, 24 Sep 2023 15:35:47 +0200
Subject: [PATCH 001/105] Checkpoint

New trait bounds for arithmetic

but getting the following error

overflow evaluating the requirement `&ordered_float::OrderedFloat<_>: Neg`

I guess I need to constrain that type to `Linear`
---
 src/ff/mod.rs                                 | 94 +++++++++++--------
 src/secret_sharing/mod.rs                     | 44 +++++++++
 .../replicated/malicious/additive_share.rs    | 57 +++++++++--
 .../replicated/semi_honest/additive_share.rs  | 56 +++++++++--
 src/secret_sharing/scheme.rs                  | 11 ++-
 5 files changed, 208 insertions(+), 54 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 21b0b70d3..f2cc12569 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -15,60 +15,78 @@ use generic_array::{ArrayLength, GenericArray};
 pub use prime_field::Fp31;
 pub use prime_field::{Fp32BitPrime, PrimeField};
 
-use crate::secret_sharing::SharedValue;
-
 #[derive(Debug, thiserror::Error, PartialEq, Eq)]
 pub enum Error {
     #[error("unknown field type {type_str}")]
     UnknownField { type_str: String },
 }
 
-pub trait ArithmeticOps:
-    Add<Output = Self>
-    + AddAssign
-    + Sub<Output = Self>
-    + SubAssign
-    + Mul<Output = Self>
-    + MulAssign
-    + Neg<Output = Self>
-    + Sized
+/// Arithmetic operations that do not require communication in our MPC setting and can be performed
+/// locally.
+pub trait LocalArithmeticOps<Rhs = Self, Output = Self>:
+Add<Rhs, Output = Output>
++ AddAssign<Rhs>
++ Sub<Rhs, Output = Output>
++ SubAssign<Rhs>
++ Neg<Output = Output>
++ Sized
 {
 }
 
-impl<T> ArithmeticOps for T where
-    T: Add<Output = Self>
-        + AddAssign
-        + Sub<Output = Self>
-        + SubAssign
-        + Mul<Output = Self>
-        + MulAssign
-        + Neg<Output = Self>
-        + Sized
+/// TODO: add docs
+/// May or may not require communication, depending on the value. Multiplying field values is a
+/// local operation, while multiplying secret shares is not.
+pub trait ArithmeticOps<Rhs = Self, Output = Self>: LocalArithmeticOps<Rhs, Output>
+// TODO: make mul a trait and implement it for secret sharing
+    + Mul<Rhs, Output = Output>
+    + MulAssign<Rhs>
 {
 }
 
-pub trait ArithmeticRefOps<V: SharedValue>:
-    for<'a> Add<&'a Self, Output = Self>
-    + for<'a> AddAssign<&'a Self>
-    + Neg<Output = Self>
-    + for<'a> Sub<&'a Self, Output = Self>
-    + for<'a> SubAssign<&'a Self>
-    + Mul<V, Output = Self>
-{
-}
+/// The trait for references which implement local arithmetic operations, taking the
+/// second operand either by value or by reference.
+///
+/// This is automatically implemented for types which implement the operators.
+pub trait RefLocalArithmeticOps<Base>: LocalArithmeticOps<Base, Base> + for <'r> LocalArithmeticOps<&'r Base, Base> {}
+impl<T, Base> RefLocalArithmeticOps<Base> for T where T: LocalArithmeticOps<Base, Base> + for<'r> LocalArithmeticOps<&'r Base, Base> {}
 
-impl<T, V> ArithmeticRefOps<V> for T
-where
-    T: for<'a> Add<&'a Self, Output = Self>
-        + for<'a> AddAssign<&'a Self>
-        + Neg<Output = Self>
-        + for<'a> Sub<&'a Self, Output = Self>
-        + for<'a> SubAssign<&'a Self>
-        + Mul<V, Output = Self>,
-    V: SharedValue,
+impl<T, Rhs, Output> LocalArithmeticOps<Rhs, Output> for T where
+    T: Add<Rhs, Output = Output>
+    + AddAssign<Rhs>
+    + Sub<Rhs, Output = Output>
+    + SubAssign<Rhs>
+    + Neg<Output = Output>
+    + Sized {}
+
+impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
+    T: LocalArithmeticOps<Rhs, Output>
+    + Mul<Rhs, Output = Output>
+    + MulAssign<Rhs>
 {
 }
 
+// pub trait ArithmeticRefOps<V: SharedValue>:
+//     for<'a> Add<&'a Self, Output = Self>
+//     + for<'a> AddAssign<&'a Self>
+//     + Neg<Output = Self>
+//     + for<'a> Sub<&'a Self, Output = Self>
+//     + for<'a> SubAssign<&'a Self>
+//     + Mul<V, Output = Self>
+// {
+// }
+//
+// impl<T, V> ArithmeticRefOps<V> for T
+// where
+//     T: for<'a> Add<&'a Self, Output = Self>
+//         + for<'a> AddAssign<&'a Self>
+//         + Neg<Output = Self>
+//         + for<'a> Sub<&'a Self, Output = Self>
+//         + for<'a> SubAssign<&'a Self>
+//         + Mul<V, Output = Self>,
+//     V: SharedValue,
+// {
+// }
+
 /// Trait for items that have fixed-byte length representation.
 pub trait Serializable: Sized {
     /// Required number of bytes to store this message on disk/network
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index c4bf6551a..b6ebdf87d 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -27,6 +27,7 @@ pub trait Block: Sized + Copy + Debug {
 }
 
 pub trait SharedValue:
+// TODO: add reference operations
     Clone + Copy + PartialEq + Debug + Send + Sync + Sized + ArithmeticOps + Serializable + 'static
 {
     type Storage: Block;
@@ -54,3 +55,46 @@ where
         ]
     }
 }
+
+
+#[cfg(all(test, unit_test))]
+mod tests {
+    use crate::ff::{Field, Fp31, RefLocalArithmeticOps};
+    use crate::secret_sharing::Linear;
+    use crate::secret_sharing::replicated::semi_honest::AdditiveShare;
+
+    #[test]
+    fn arithmetic() {
+        let a = AdditiveShare::<Fp31>::ZERO;
+        let b = AdditiveShare::<Fp31>::ZERO;
+
+        assert_eq!(AdditiveShare::ZERO, &a + &b);
+        assert_eq!(AdditiveShare::ZERO, a.clone() + &b);
+        assert_eq!(AdditiveShare::ZERO, &a + b.clone());
+        assert_eq!(AdditiveShare::ZERO, a + b);
+    }
+
+    #[test]
+    fn trait_bounds() {
+        fn sum_owned<S: Linear<Fp31>>(a: S, b: S) -> S {
+            a + b
+        }
+
+        fn sum_ref_ref<S>(a: &S, b: &S) -> S where S: Linear<Fp31>, for <'a> &'a S: RefLocalArithmeticOps<S> {
+            a + b
+        }
+
+        fn sum_owned_ref<S: Linear<Fp31>>(a: S, b: &S) -> S {
+            a + b
+        }
+
+        fn sum_ref_owned<S>(a: &S, b: S) -> S where S: Linear<Fp31>, for <'a> &'a S: RefLocalArithmeticOps<S> {
+            a + b
+        }
+
+        assert_eq!(AdditiveShare::ZERO, sum_owned(AdditiveShare::ZERO, AdditiveShare::ZERO));
+        assert_eq!(AdditiveShare::ZERO, sum_ref_ref(&AdditiveShare::ZERO, &AdditiveShare::ZERO));
+        assert_eq!(AdditiveShare::ZERO, sum_owned_ref(AdditiveShare::ZERO, &AdditiveShare::ZERO));
+        assert_eq!(AdditiveShare::ZERO, sum_ref_owned(&AdditiveShare::ZERO, AdditiveShare::ZERO));
+    }
+}
diff --git a/src/secret_sharing/replicated/malicious/additive_share.rs b/src/secret_sharing/replicated/malicious/additive_share.rs
index 043710dd3..14d38f8fe 100644
--- a/src/secret_sharing/replicated/malicious/additive_share.rs
+++ b/src/secret_sharing/replicated/malicious/additive_share.rs
@@ -154,12 +154,27 @@ impl<V: SharedValue + ExtendableField> Add<Self> for &AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue + ExtendableField> Add<&Self> for AdditiveShare<V> {
+impl<V: SharedValue + ExtendableField> Add<Self> for AdditiveShare<V> {
     type Output = Self;
 
-    fn add(mut self, rhs: &Self) -> Self::Output {
-        self += rhs;
-        self
+    fn add(self, rhs: Self) -> Self::Output {
+        Add::add(&self, &rhs)
+    }
+}
+
+impl<V: SharedValue + ExtendableField> Add<AdditiveShare<V>> for &AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
+
+    fn add(self, rhs: AdditiveShare<V>) -> Self::Output {
+        Add::add(self, &rhs)
+    }
+}
+
+impl<V: SharedValue + ExtendableField> Add<&AdditiveShare<V>> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn add(self, rhs: &Self) -> Self::Output {
+        Add::add(&self, rhs)
     }
 }
 
@@ -170,6 +185,12 @@ impl<V: SharedValue + ExtendableField> AddAssign<&Self> for AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue + ExtendableField> AddAssign<Self> for AdditiveShare<V> {
+    fn add_assign(&mut self, rhs: Self) {
+        AddAssign::add_assign(self, &rhs)
+    }
+}
+
 impl<V: SharedValue + ExtendableField> Neg for AdditiveShare<V> {
     type Output = Self;
 
@@ -191,12 +212,28 @@ impl<V: SharedValue + ExtendableField> Sub<Self> for &AdditiveShare<V> {
         }
     }
 }
+
+impl<V: SharedValue + ExtendableField> Sub<Self> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Sub::sub(&self, &rhs)
+    }
+}
+
 impl<V: SharedValue + ExtendableField> Sub<&Self> for AdditiveShare<V> {
     type Output = Self;
 
-    fn sub(mut self, rhs: &Self) -> Self::Output {
-        self -= rhs;
-        self
+    fn sub(self, rhs: &Self) -> Self::Output {
+        Sub::sub(&self, rhs)
+    }
+}
+
+impl<V: SharedValue + ExtendableField> Sub<AdditiveShare<V>> for &AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
+
+    fn sub(self, rhs: AdditiveShare<V>) -> Self::Output {
+        Sub::sub(self, &rhs)
     }
 }
 
@@ -207,6 +244,12 @@ impl<V: SharedValue + ExtendableField> SubAssign<&Self> for AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue + ExtendableField> SubAssign<Self> for AdditiveShare<V> {
+    fn sub_assign(&mut self, rhs: Self) {
+        SubAssign::sub_assign(self, &rhs)
+    }
+}
+
 impl<V: SharedValue + ExtendableField> Mul<V> for AdditiveShare<V> {
     type Output = Self;
 
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index b310971b8..5958882e3 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -81,12 +81,27 @@ impl<V: SharedValue> Add<Self> for &AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Add<&Self> for AdditiveShare<V> {
+impl<V: SharedValue> Add<Self> for AdditiveShare<V> {
     type Output = Self;
 
-    fn add(mut self, rhs: &Self) -> Self::Output {
-        self += rhs;
-        self
+    fn add(self, rhs: Self) -> Self::Output {
+        Add::add(&self, &rhs)
+    }
+}
+
+impl<V: SharedValue> Add<AdditiveShare<V>> for &AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
+
+    fn add(self, rhs: AdditiveShare<V>) -> Self::Output {
+        Add::add(self, &rhs)
+    }
+}
+
+impl<V: SharedValue> Add<&AdditiveShare<V>> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn add(self, rhs: &Self) -> Self::Output {
+        Add::add(&self, rhs)
     }
 }
 
@@ -97,6 +112,12 @@ impl<V: SharedValue> AddAssign<&Self> for AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue> AddAssign<Self> for AdditiveShare<V> {
+    fn add_assign(&mut self, rhs: Self) {
+        AddAssign::add_assign(self, &rhs)
+    }
+}
+
 impl<V: SharedValue> Neg for AdditiveShare<V> {
     type Output = Self;
 
@@ -113,12 +134,27 @@ impl<V: SharedValue> Sub<Self> for &AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue> Sub<Self> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Sub::sub(&self, &rhs)
+    }
+}
+
 impl<V: SharedValue> Sub<&Self> for AdditiveShare<V> {
     type Output = Self;
 
-    fn sub(mut self, rhs: &Self) -> Self::Output {
-        self -= rhs;
-        self
+    fn sub(self, rhs: &Self) -> Self::Output {
+        Sub::sub(&self, rhs)
+    }
+}
+
+impl<V: SharedValue> Sub<AdditiveShare<V>> for &AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
+
+    fn sub(self, rhs: AdditiveShare<V>) -> Self::Output {
+        Sub::sub(self, &rhs)
     }
 }
 
@@ -129,6 +165,12 @@ impl<V: SharedValue> SubAssign<&Self> for AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue> SubAssign<Self> for AdditiveShare<V> {
+    fn sub_assign(&mut self, rhs: Self) {
+        SubAssign::sub_assign(self, &rhs)
+    }
+}
+
 impl<V: SharedValue> Mul<V> for AdditiveShare<V> {
     type Output = Self;
 
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index 262891252..7b9f6bd03 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -1,7 +1,8 @@
 use std::fmt::Debug;
+use std::ops::Mul;
 
 use super::SharedValue;
-use crate::ff::{ArithmeticRefOps, GaloisField};
+use crate::ff::{GaloisField, LocalArithmeticOps};
 
 /// Secret sharing scheme i.e. Replicated secret sharing
 pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
@@ -9,7 +10,13 @@ pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
 }
 
 /// Secret share of a secret that has additive and multiplicative properties.
-pub trait Linear<V: SharedValue>: SecretSharing<V> + ArithmeticRefOps<V> {}
+pub trait Linear<V: SharedValue>:
+SecretSharing<V>
++ LocalArithmeticOps
++ for<'r> LocalArithmeticOps<&'r Self>
+// TODO: add reference
++ Mul<V, Output = Self>
+{}
 
 /// Secret share of a secret in bits. It has additive and multiplicative properties.
 pub trait Bitwise<V: GaloisField>: SecretSharing<V> + Linear<V> {}

From d5dc178ffe8d83b5d8cf6f4216565b6670c33323 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Sun, 24 Sep 2023 20:37:46 +0200
Subject: [PATCH 002/105] Goodness gracious, it compiles!

If this plane did not have a WiFi, I'd never be able to do it.

It seems that `Neg` was tripping me off - adding it as a constraint to trait <A, B> and only constraining it to B, makes the compiler go to infinite loop trying to evaluate all possible types that can fit. At the end, I was getting the gnarly "overflow evaluating ..." error

So structure needs to be as follows:

* Traits that have Rhs and Output
* Traits that only have Output
* Traits that are valid for secret sharing (add, sub, neg)
* Traits that are valid for basic arithmetic (mul)
---
 src/ff/mod.rs                                 | 45 ++++++++++---------
 src/protocol/basics/reveal.rs                 |  2 +-
 src/secret_sharing/mod.rs                     | 20 +++++----
 .../replicated/semi_honest/additive_share.rs  | 23 +++++++---
 src/secret_sharing/scheme.rs                  | 10 ++++-
 5 files changed, 63 insertions(+), 37 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index f2cc12569..9dc7f3c5a 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -25,46 +25,51 @@ pub enum Error {
 /// locally.
 pub trait LocalArithmeticOps<Rhs = Self, Output = Self>:
 Add<Rhs, Output = Output>
-+ AddAssign<Rhs>
+// + AddAssign<Rhs>
 + Sub<Rhs, Output = Output>
-+ SubAssign<Rhs>
-+ Neg<Output = Output>
+// + SubAssign<Rhs>
+// + Neg<Output = Output>
 + Sized
 {
 }
 
+impl<T, Rhs, Output> LocalArithmeticOps<Rhs, Output> for T where
+    T: Add<Rhs, Output = Output>
+    // + AddAssign<Rhs>
+    + Sub<Rhs, Output = Output>
+    // + SubAssign<Rhs>
+    // + Neg<Output = Output>
+    + Sized {}
+
+
+pub trait LocalAssignOps<Rhs = Self>: AddAssign<Rhs> + SubAssign<Rhs> + Neg<Output = Self> {}
+impl <T, Rhs> LocalAssignOps<Rhs> for T where T:AddAssign<Rhs> + SubAssign<Rhs> + Neg<Output = Self> {}
+
 /// TODO: add docs
 /// May or may not require communication, depending on the value. Multiplying field values is a
 /// local operation, while multiplying secret shares is not.
-pub trait ArithmeticOps<Rhs = Self, Output = Self>: LocalArithmeticOps<Rhs, Output>
+pub trait ArithmeticOps<Rhs = Self, Output = Self>: LocalArithmeticOps<Rhs, Output> + LocalAssignOps<Rhs>
 // TODO: make mul a trait and implement it for secret sharing
     + Mul<Rhs, Output = Output>
     + MulAssign<Rhs>
 {
 }
 
-/// The trait for references which implement local arithmetic operations, taking the
-/// second operand either by value or by reference.
-///
-/// This is automatically implemented for types which implement the operators.
-pub trait RefLocalArithmeticOps<Base>: LocalArithmeticOps<Base, Base> + for <'r> LocalArithmeticOps<&'r Base, Base> {}
-impl<T, Base> RefLocalArithmeticOps<Base> for T where T: LocalArithmeticOps<Base, Base> + for<'r> LocalArithmeticOps<&'r Base, Base> {}
-
-impl<T, Rhs, Output> LocalArithmeticOps<Rhs, Output> for T where
-    T: Add<Rhs, Output = Output>
-    + AddAssign<Rhs>
-    + Sub<Rhs, Output = Output>
-    + SubAssign<Rhs>
-    + Neg<Output = Output>
-    + Sized {}
-
 impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
-    T: LocalArithmeticOps<Rhs, Output>
+    T: LocalArithmeticOps<Rhs, Output> + LocalAssignOps<Rhs>
     + Mul<Rhs, Output = Output>
     + MulAssign<Rhs>
 {
 }
 
+/// The trait for references which implement local arithmetic operations, taking the
+/// second operand either by value or by reference.
+///
+/// This is automatically implemented for types which implement the operators.
+// pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<&'a Base, Base> {}
+
+// impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<&'a Base, Base> + 'a {}
+
 // pub trait ArithmeticRefOps<V: SharedValue>:
 //     for<'a> Add<&'a Self, Output = Self>
 //     + for<'a> AddAssign<&'a Self>
diff --git a/src/protocol/basics/reveal.rs b/src/protocol/basics/reveal.rs
index 28e54a904..d89fb7ec6 100644
--- a/src/protocol/basics/reveal.rs
+++ b/src/protocol/basics/reveal.rs
@@ -255,7 +255,7 @@ mod tests {
 
         let m_shares = join3v(
             zip(m_ctx.iter(), input.share_with(&mut rng))
-                .map(|(m_ctx, share)| async { m_ctx.upgrade(share).await }),
+                .map(|(m_ctx, share)| async move { m_ctx.upgrade(share).await }),
         )
         .await;
         let result = try_join3(
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index b6ebdf87d..7b7b25af6 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -59,9 +59,11 @@ where
 
 #[cfg(all(test, unit_test))]
 mod tests {
-    use crate::ff::{Field, Fp31, RefLocalArithmeticOps};
-    use crate::secret_sharing::Linear;
+    use std::ops::Add;
+    use crate::ff::{Field, Fp31};
+    use crate::secret_sharing::{Linear, SharedValue};
     use crate::secret_sharing::replicated::semi_honest::AdditiveShare;
+    use crate::secret_sharing::scheme::RefLocalArithmeticOps;
 
     #[test]
     fn arithmetic() {
@@ -80,7 +82,7 @@ mod tests {
             a + b
         }
 
-        fn sum_ref_ref<S>(a: &S, b: &S) -> S where S: Linear<Fp31>, for <'a> &'a S: RefLocalArithmeticOps<S> {
+        fn sum_ref_ref<S>(a: &S, b: &S) -> S where S: Linear<Fp31>, for <'a> &'a S: RefLocalArithmeticOps<'a, S> {
             a + b
         }
 
@@ -88,13 +90,15 @@ mod tests {
             a + b
         }
 
-        fn sum_ref_owned<S>(a: &S, b: S) -> S where S: Linear<Fp31>, for <'a> &'a S: RefLocalArithmeticOps<S> {
-            a + b
-        }
+        // fn sum_ref_owned<S, V>(a: &S, b: S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<S> {
+        //     a + b
+        // }
 
         assert_eq!(AdditiveShare::ZERO, sum_owned(AdditiveShare::ZERO, AdditiveShare::ZERO));
-        assert_eq!(AdditiveShare::ZERO, sum_ref_ref(&AdditiveShare::ZERO, &AdditiveShare::ZERO));
+        assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_ref_ref(&AdditiveShare::<Fp31>::ZERO, &AdditiveShare::ZERO));
         assert_eq!(AdditiveShare::ZERO, sum_owned_ref(AdditiveShare::ZERO, &AdditiveShare::ZERO));
-        assert_eq!(AdditiveShare::ZERO, sum_ref_owned(&AdditiveShare::ZERO, AdditiveShare::ZERO));
+        // assert_eq!(0, sum_ref_owned(&0_i32, 1));
+        // assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_ref_owned::<AdditiveShare<Fp31>, _>(&AdditiveShare::ZERO, AdditiveShare::ZERO))
+        // assert_eq!(AdditiveShare::ZERO, sum_ref_owned::<AdditiveShare<Fp31>>(&AdditiveShare::ZERO, AdditiveShare::ZERO));
     }
 }
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index 5958882e3..1d83d3f76 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -13,6 +13,7 @@ use crate::{
         SharedValue,
     },
 };
+use crate::secret_sharing::scheme::RefLocalArithmeticOps;
 
 #[derive(Clone, PartialEq, Eq)]
 pub struct AdditiveShare<V: SharedValue>(V, V);
@@ -23,6 +24,8 @@ impl<V: SharedValue> SecretSharing<V> for AdditiveShare<V> {
 
 impl<V: SharedValue> LinearSecretSharing<V> for AdditiveShare<V> {}
 
+// impl <'a, V: SharedValue> RefLocalArithmeticOps<'a, Self> for AdditiveShare<V> {}
+
 impl<V: SharedValue + Debug> Debug for AdditiveShare<V> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "({:?}, {:?})", self.0, self.1)
@@ -73,10 +76,10 @@ where
     }
 }
 
-impl<V: SharedValue> Add<Self> for &AdditiveShare<V> {
+impl<'a, 'b, V: SharedValue> Add<&'b AdditiveShare<V>> for &'a AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
-    fn add(self, rhs: Self) -> Self::Output {
+    fn add(self, rhs: &'b AdditiveShare<V>) -> Self::Output {
         AdditiveShare(self.0 + rhs.0, self.1 + rhs.1)
     }
 }
@@ -89,7 +92,7 @@ impl<V: SharedValue> Add<Self> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Add<AdditiveShare<V>> for &AdditiveShare<V> {
+impl<'a, V: SharedValue> Add<AdditiveShare<V>> for &'a AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
     fn add(self, rhs: AdditiveShare<V>) -> Self::Output {
@@ -97,10 +100,10 @@ impl<V: SharedValue> Add<AdditiveShare<V>> for &AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Add<&AdditiveShare<V>> for AdditiveShare<V> {
+impl<'a, V: SharedValue> Add<&'a AdditiveShare<V>> for AdditiveShare<V> {
     type Output = Self;
 
-    fn add(self, rhs: &Self) -> Self::Output {
+    fn add(self, rhs: &'a Self) -> Self::Output {
         Add::add(&self, rhs)
     }
 }
@@ -118,11 +121,19 @@ impl<V: SharedValue> AddAssign<Self> for AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue> Neg for &AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
+
+    fn neg(self) -> Self::Output {
+        AdditiveShare(-self.0, -self.1)
+    }
+}
+
 impl<V: SharedValue> Neg for AdditiveShare<V> {
     type Output = Self;
 
     fn neg(self) -> Self::Output {
-        Self(-self.0, -self.1)
+        Neg::neg(&self)
     }
 }
 
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index 7b9f6bd03..ed6a23e31 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -1,8 +1,8 @@
 use std::fmt::Debug;
-use std::ops::Mul;
+use std::ops::{Mul, Neg};
 
 use super::SharedValue;
-use crate::ff::{GaloisField, LocalArithmeticOps};
+use crate::ff::{GaloisField, LocalArithmeticOps, LocalAssignOps};
 
 /// Secret sharing scheme i.e. Replicated secret sharing
 pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
@@ -13,10 +13,16 @@ pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
 pub trait Linear<V: SharedValue>:
 SecretSharing<V>
 + LocalArithmeticOps
++ LocalAssignOps
 + for<'r> LocalArithmeticOps<&'r Self>
++ for<'r> LocalAssignOps<&'r Self>
 // TODO: add reference
 + Mul<V, Output = Self>
++ Neg<Output = Self>
 {}
 
+pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<&'a Base, Base> {}
+impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<&'a Base, Base> + 'a {}
+
 /// Secret share of a secret in bits. It has additive and multiplicative properties.
 pub trait Bitwise<V: GaloisField>: SecretSharing<V> + Linear<V> {}

From fcf3737fab967e79516d3b3944a0eea6cb50f865 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Mon, 25 Sep 2023 14:06:44 -0700
Subject: [PATCH 003/105] Make all 4 use cases work

---
 src/secret_sharing/mod.rs                     | 19 ++++++++-----------
 .../replicated/semi_honest/additive_share.rs  |  1 -
 src/secret_sharing/scheme.rs                  |  4 ++--
 3 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 7b7b25af6..7d3cd8484 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -59,8 +59,7 @@ where
 
 #[cfg(all(test, unit_test))]
 mod tests {
-    use std::ops::Add;
-    use crate::ff::{Field, Fp31};
+    use crate::ff::{Fp31};
     use crate::secret_sharing::{Linear, SharedValue};
     use crate::secret_sharing::replicated::semi_honest::AdditiveShare;
     use crate::secret_sharing::scheme::RefLocalArithmeticOps;
@@ -82,23 +81,21 @@ mod tests {
             a + b
         }
 
-        fn sum_ref_ref<S>(a: &S, b: &S) -> S where S: Linear<Fp31>, for <'a> &'a S: RefLocalArithmeticOps<'a, S> {
+        fn sum_ref_ref<S, V>(a: &S, b: &S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S> {
             a + b
         }
 
-        fn sum_owned_ref<S: Linear<Fp31>>(a: S, b: &S) -> S {
+        fn sum_owned_ref<S: Linear<V>, V: SharedValue>(a: S, b: &S) -> S {
             a + b
         }
 
-        // fn sum_ref_owned<S, V>(a: &S, b: S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<S> {
-        //     a + b
-        // }
+        fn sum_ref_owned<S, V>(a: &S, b: S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S> {
+            a + b
+        }
 
         assert_eq!(AdditiveShare::ZERO, sum_owned(AdditiveShare::ZERO, AdditiveShare::ZERO));
         assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_ref_ref(&AdditiveShare::<Fp31>::ZERO, &AdditiveShare::ZERO));
-        assert_eq!(AdditiveShare::ZERO, sum_owned_ref(AdditiveShare::ZERO, &AdditiveShare::ZERO));
-        // assert_eq!(0, sum_ref_owned(&0_i32, 1));
-        // assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_ref_owned::<AdditiveShare<Fp31>, _>(&AdditiveShare::ZERO, AdditiveShare::ZERO))
-        // assert_eq!(AdditiveShare::ZERO, sum_ref_owned::<AdditiveShare<Fp31>>(&AdditiveShare::ZERO, AdditiveShare::ZERO));
+        assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_owned_ref(AdditiveShare::ZERO, &AdditiveShare::ZERO));
+        assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_ref_owned(&AdditiveShare::ZERO, AdditiveShare::ZERO))
     }
 }
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index 1d83d3f76..34a063e53 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -13,7 +13,6 @@ use crate::{
         SharedValue,
     },
 };
-use crate::secret_sharing::scheme::RefLocalArithmeticOps;
 
 #[derive(Clone, PartialEq, Eq)]
 pub struct AdditiveShare<V: SharedValue>(V, V);
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index ed6a23e31..fb6ea01fd 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -21,8 +21,8 @@ SecretSharing<V>
 + Neg<Output = Self>
 {}
 
-pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<&'a Base, Base> {}
-impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<&'a Base, Base> + 'a {}
+pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> {}
+impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> + 'a {}
 
 /// Secret share of a secret in bits. It has additive and multiplicative properties.
 pub trait Bitwise<V: GaloisField>: SecretSharing<V> + Linear<V> {}

From 2143a0a146c2f0e08d3b8091c7edb7c31b8a78d8 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Mon, 25 Sep 2023 14:32:43 -0700
Subject: [PATCH 004/105] Tests for both malicious and semi-honest

---
 src/secret_sharing/mod.rs    | 45 ++++++++++++++++++++++--------------
 src/secret_sharing/scheme.rs | 17 +++++++-------
 2 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 7d3cd8484..14a07c2ed 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -61,23 +61,22 @@ where
 mod tests {
     use crate::ff::{Fp31};
     use crate::secret_sharing::{Linear, SharedValue};
-    use crate::secret_sharing::replicated::semi_honest::AdditiveShare;
+    use crate::secret_sharing::replicated::{malicious, semi_honest};
     use crate::secret_sharing::scheme::RefLocalArithmeticOps;
 
-    #[test]
-    fn arithmetic() {
-        let a = AdditiveShare::<Fp31>::ZERO;
-        let b = AdditiveShare::<Fp31>::ZERO;
-
-        assert_eq!(AdditiveShare::ZERO, &a + &b);
-        assert_eq!(AdditiveShare::ZERO, a.clone() + &b);
-        assert_eq!(AdditiveShare::ZERO, &a + b.clone());
-        assert_eq!(AdditiveShare::ZERO, a + b);
+    fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L> {
+        let a = L::ZERO;
+        let b = L::ZERO;
+
+        assert_eq!(L::ZERO, &a + &b);
+        assert_eq!(L::ZERO, a.clone() + &b);
+        assert_eq!(L::ZERO, &a + b.clone());
+        assert_eq!(L::ZERO, a + b);
     }
 
-    #[test]
-    fn trait_bounds() {
-        fn sum_owned<S: Linear<Fp31>>(a: S, b: S) -> S {
+    fn trait_bounds<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L> {
+
+        fn sum_owned<S: Linear<V>, V: SharedValue>(a: S, b: S) -> S {
             a + b
         }
 
@@ -93,9 +92,21 @@ mod tests {
             a + b
         }
 
-        assert_eq!(AdditiveShare::ZERO, sum_owned(AdditiveShare::ZERO, AdditiveShare::ZERO));
-        assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_ref_ref(&AdditiveShare::<Fp31>::ZERO, &AdditiveShare::ZERO));
-        assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_owned_ref(AdditiveShare::ZERO, &AdditiveShare::ZERO));
-        assert_eq!(AdditiveShare::<Fp31>::ZERO, sum_ref_owned(&AdditiveShare::ZERO, AdditiveShare::ZERO))
+        assert_eq!(L::ZERO, sum_owned(L::ZERO, L::ZERO));
+        assert_eq!(L::ZERO, sum_ref_ref(&L::ZERO, &L::ZERO));
+        assert_eq!(L::ZERO, sum_owned_ref(L::ZERO, &L::ZERO));
+        assert_eq!(L::ZERO, sum_ref_owned(&L::ZERO, L::ZERO))
+    }
+
+    #[test]
+    fn semi_honest() {
+        arithmetic::<semi_honest::AdditiveShare<Fp31>, _>();
+        trait_bounds::<semi_honest::AdditiveShare<Fp31>, _>();
+    }
+
+    #[test]
+    fn malicious() {
+        arithmetic::<malicious::AdditiveShare<Fp31>, _>();
+        trait_bounds::<malicious::AdditiveShare<Fp31>, _>();
     }
 }
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index fb6ea01fd..130a80499 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -10,15 +10,14 @@ pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
 }
 
 /// Secret share of a secret that has additive and multiplicative properties.
-pub trait Linear<V: SharedValue>:
-SecretSharing<V>
-+ LocalArithmeticOps
-+ LocalAssignOps
-+ for<'r> LocalArithmeticOps<&'r Self>
-+ for<'r> LocalAssignOps<&'r Self>
-// TODO: add reference
-+ Mul<V, Output = Self>
-+ Neg<Output = Self>
+pub trait Linear<V: SharedValue>: SecretSharing<V>
+    + LocalArithmeticOps
+    + LocalAssignOps
+    + for<'r> LocalArithmeticOps<&'r Self>
+    + for<'r> LocalAssignOps<&'r Self>
+    // TODO: add reference
+    + Mul<V, Output=Self>
+    + Neg<Output=Self>
 {}
 
 pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> {}

From 8b3ac2aa123bacabfa67cb619e0dcde1ab98da89 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Mon, 25 Sep 2023 14:37:29 -0700
Subject: [PATCH 005/105] Make Add for malicious share mimic semi honest
 definition

---
 src/secret_sharing/replicated/malicious/additive_share.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/secret_sharing/replicated/malicious/additive_share.rs b/src/secret_sharing/replicated/malicious/additive_share.rs
index 14d38f8fe..183560bbd 100644
--- a/src/secret_sharing/replicated/malicious/additive_share.rs
+++ b/src/secret_sharing/replicated/malicious/additive_share.rs
@@ -143,10 +143,10 @@ impl<V: SharedValue + ExtendableField> AdditiveShare<V> {
     };
 }
 
-impl<V: SharedValue + ExtendableField> Add<Self> for &AdditiveShare<V> {
+impl<'a, 'b, V: SharedValue + ExtendableField> Add<&'b AdditiveShare<V>> for &'a AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
-    fn add(self, rhs: Self) -> Self::Output {
+    fn add(self, rhs: &'b AdditiveShare<V>) -> Self::Output {
         AdditiveShare {
             x: &self.x + &rhs.x,
             rx: &self.rx + &rhs.rx,

From 53c6883ad999881f49e0640dbc3304e42ee0cab4 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Mon, 25 Sep 2023 15:51:16 -0700
Subject: [PATCH 006/105] Remove clones from add and sub operations

Add new trait bound to fix it
---
 src/ff/mod.rs                                        |  3 ++-
 src/protocol/attribution/apply_attribution_window.rs |  6 +++++-
 src/protocol/attribution/credit_capping.rs           |  7 ++++++-
 src/protocol/attribution/mod.rs                      |  4 ++++
 src/protocol/basics/if_else.rs                       |  4 +++-
 src/protocol/boolean/bitwise_equal.rs                |  7 +++++--
 src/protocol/boolean/comparison.rs                   | 11 ++++++++---
 src/protocol/ipa/mod.rs                              |  3 +++
 src/protocol/sort/bit_permutation.rs                 |  6 ++++--
 src/query/runner/ipa.rs                              |  3 +++
 src/secret_sharing/mod.rs                            |  3 +--
 src/secret_sharing/scheme.rs                         |  2 --
 12 files changed, 44 insertions(+), 15 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 9dc7f3c5a..bd3a50e5f 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -66,7 +66,8 @@ impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
 /// second operand either by value or by reference.
 ///
 /// This is automatically implemented for types which implement the operators.
-// pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<&'a Base, Base> {}
+pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> {}
+impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> + 'a {}
 
 // impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<&'a Base, Base> + 'a {}
 
diff --git a/src/protocol/attribution/apply_attribution_window.rs b/src/protocol/attribution/apply_attribution_window.rs
index 93c82859a..845ecc0e3 100644
--- a/src/protocol/attribution/apply_attribution_window.rs
+++ b/src/protocol/attribution/apply_attribution_window.rs
@@ -19,6 +19,7 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 /// This protocol applies the specified attribution window to trigger events. All trigger values of
 /// events that are outside the window will be replaced with 0, hence will not be attributed to
@@ -37,6 +38,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + 'static,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     if let Some(attribution_window_seconds) = attribution_window_seconds {
         let mut t_deltas = prefix_sum_time_deltas(&ctx, input, stop_bits).await?;
@@ -90,6 +92,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a T: RefLocalArithmeticOps<'a, T>,
 {
     let num_rows = input.len();
 
@@ -108,7 +111,7 @@ where
                     .map(|(i, ((prev, curr), b))| {
                         let c = t_delta_context.clone();
                         let record_id = RecordId::from(i);
-                        let delta = curr.timestamp.clone() - &prev.timestamp;
+                        let delta = &curr.timestamp - &prev.timestamp;
                         async move { delta.multiply(b, c, record_id).await }
                     }),
             )
@@ -149,6 +152,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     let ctx = ctx.set_total_records(input.len());
     let random_bits_generator =
diff --git a/src/protocol/attribution/credit_capping.rs b/src/protocol/attribution/credit_capping.rs
index f4ec66edc..3b2bad98d 100644
--- a/src/protocol/attribution/credit_capping.rs
+++ b/src/protocol/attribution/credit_capping.rs
@@ -19,6 +19,7 @@ use crate::{
     secret_sharing::Linear as LinearSecretSharing,
     seq_join::seq_join,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 /// User-level credit capping protocol.
 ///
@@ -35,6 +36,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     if cap == 1 {
         return Ok(credit_capping_max_one(ctx, input)
@@ -241,6 +243,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     let share_of_cap = S::share_known_value(&ctx, F::truncate_from(cap));
     let cap_ref = &share_of_cap;
@@ -295,6 +298,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(prefix_summed_credits.len());
@@ -357,6 +361,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a T: RefLocalArithmeticOps<'a, T>
 {
     let num_rows = input.len();
     let cap_share = T::share_known_value(&ctx, F::try_from(cap.into()).unwrap());
@@ -413,7 +418,7 @@ where
                     record_id,
                     next_credit_exceeds_cap,
                     &T::ZERO,
-                    &(cap.clone() - next_prefix_summed_credit),
+                    &(cap - next_prefix_summed_credit),
                 )
                 .await?,
                 cap,
diff --git a/src/protocol/attribution/mod.rs b/src/protocol/attribution/mod.rs
index 43b721cd5..d3b93ff8d 100644
--- a/src/protocol/attribution/mod.rs
+++ b/src/protocol/attribution/mod.rs
@@ -39,6 +39,7 @@ use crate::{
     },
     seq_join::assert_send,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 /// Performs a set of attribution protocols on the sorted IPA input.
 ///
@@ -62,11 +63,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB> + Context,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
+    for <'a> &'a SB: RefLocalArithmeticOps<'a, SB>,
     F: PrimeField + ExtendableField,
     ShuffledPermutationWrapper<S, C::UpgradedContext<F>>: DowngradeMalicious<Target = Vec<u32>>,
 {
@@ -403,6 +406,7 @@ async fn compute_helper_bits_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     let narrowed_ctx = ctx
         .narrow(&Step::ComputeHelperBits)
diff --git a/src/protocol/basics/if_else.rs b/src/protocol/basics/if_else.rs
index 38d5b4ab3..cf8a9ed70 100644
--- a/src/protocol/basics/if_else.rs
+++ b/src/protocol/basics/if_else.rs
@@ -4,6 +4,7 @@ use crate::{
     protocol::{basics::SecureMul, context::Context, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 /// Returns `true_value` if `condition` is a share of 1, else `false_value`.
 /// # Errors
@@ -19,6 +20,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + SecureMul<C>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     // If `condition` is a share of 1 (true), then
     //   = false_value + 1 * (true_value - false_value)
@@ -30,6 +32,6 @@ where
     //   = false_value
     Ok(false_value.clone()
         + &condition
-            .multiply(&(true_value.clone() - false_value), ctx, record_id)
+            .multiply(&(true_value - false_value), ctx, record_id)
             .await?)
 }
diff --git a/src/protocol/boolean/bitwise_equal.rs b/src/protocol/boolean/bitwise_equal.rs
index 0f67e4e4f..7bff2a07a 100644
--- a/src/protocol/boolean/bitwise_equal.rs
+++ b/src/protocol/boolean/bitwise_equal.rs
@@ -6,6 +6,7 @@ use crate::{
     protocol::{boolean::all_zeroes, context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 /// Compares `[a]` and `c`, and returns 1 iff `a == c`
 ///
@@ -24,6 +25,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     assert!(a.len() <= 128);
 
@@ -36,7 +38,7 @@ where
             if ((c >> i) & 1) == 0 {
                 a_bit.clone()
             } else {
-                one.clone() - a_bit
+                &one - a_bit
             }
         })
         .collect::<Vec<_>>();
@@ -56,10 +58,11 @@ pub async fn bitwise_equal_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     debug_assert!(a.len() == b.len());
     let c = zip(a.iter(), b.iter())
-        .map(|(a_bit, b_bit)| a_bit.clone() - b_bit)
+        .map(|(a_bit, b_bit)| a_bit - b_bit)
         .collect::<Vec<_>>();
 
     all_zeroes(ctx, record_id, &c).await
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 35765c7d2..0b95533d5 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -12,6 +12,7 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 // Compare an arithmetic-shared value `a` to a known value `c`.
 //
@@ -73,6 +74,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     use GreaterThanConstantStep as Step;
 
@@ -81,7 +83,7 @@ where
     let r = rbg.generate(record_id).await?;
 
     // Mask `a` with random `r` and reveal.
-    let b = (r.b_p.clone() + a)
+    let b = (r.b_p + a)
         .reveal(ctx.narrow(&Step::Reveal), record_id)
         .await?;
 
@@ -174,6 +176,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     assert!(a.len() <= 128);
 
@@ -206,6 +209,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     assert!(a.len() <= 128);
 
@@ -236,6 +240,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
 {
     let one = S::share_known_value(ctx, F::ONE);
 
@@ -248,7 +253,7 @@ where
             if ((b >> i) & 1) == 0 {
                 a_bit.clone()
             } else {
-                one.clone() - a_bit
+                &one - a_bit
             }
         })
         .collect::<Vec<_>>();
@@ -278,7 +283,7 @@ where
         // differing bit. Note that at the index where the transition from 0 to 1 happens,
         // `prefix_or[i + 1] > prefix_or[i]`. Do not change the order of the subtraction
         // unless we use Fp2, or the result will be `[p-1]`.
-        first_diff_bit.push(result.clone() - &previous_bit);
+        first_diff_bit.push(&result - &previous_bit);
 
         previous_bit = result;
     }
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index 940c41ef7..acec56801 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -38,6 +38,7 @@ use crate::{
         BitDecomposed, Linear as LinearSecretSharing,
     },
 };
+use crate::ff::RefLocalArithmeticOps;
 
 #[derive(Step)]
 pub(crate) enum Step {
@@ -315,11 +316,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
+    for <'r> &'r S: RefLocalArithmeticOps<'r, S>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
+    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB>,
     F: PrimeField + ExtendableField,
     MK: GaloisField,
     BK: GaloisField,
diff --git a/src/protocol/sort/bit_permutation.rs b/src/protocol/sort/bit_permutation.rs
index 3df58de89..2523378e4 100644
--- a/src/protocol/sort/bit_permutation.rs
+++ b/src/protocol/sort/bit_permutation.rs
@@ -8,6 +8,7 @@ use crate::{
     protocol::{context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 #[embed_doc_image("bit_permutation", "images/sort/bit_permutations.png")]
 /// This is an implementation of `GenBitPerm` (Algorithm 3) described in:
@@ -39,7 +40,8 @@ pub async fn bit_permutation<
 >(
     ctx: C,
     input: &[S],
-) -> Result<Vec<S>, Error> {
+) -> Result<Vec<S>, Error>
+    where for<'r> &'r S: RefLocalArithmeticOps<'r, S> {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(2 * input.len());
     let share_of_one = S::share_known_value(&ctx, F::ONE);
@@ -67,7 +69,7 @@ pub async fn bit_permutation<
     for i in 0..len {
         // we are subtracting "1" from the result since this protocol returns 1-index permutation whereas all other
         // protocols expect 0-indexed permutation
-        let less_one = mult_output[i + len].clone() - &share_of_one;
+        let less_one = &mult_output[i + len] - &share_of_one;
         mult_output[i] = less_one + &mult_output[i];
     }
     mult_output.truncate(len);
diff --git a/src/query/runner/ipa.rs b/src/query/runner/ipa.rs
index 94805bb7c..b4a652cd1 100644
--- a/src/query/runner/ipa.rs
+++ b/src/query/runner/ipa.rs
@@ -28,6 +28,7 @@ use crate::{
     },
     sync::Arc,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 pub struct IpaQuery<F, C, S> {
     config: IpaQueryConfig,
@@ -55,11 +56,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
+    for <'r> &'r S: RefLocalArithmeticOps<'r, S>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
+    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB>,
     F: PrimeField,
     Replicated<F>: Serializable + ShareKnownValue<C, F>,
     IPAInputRow<F, MatchKey, BreakdownKey>: Serializable,
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 14a07c2ed..279a65829 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -59,10 +59,9 @@ where
 
 #[cfg(all(test, unit_test))]
 mod tests {
-    use crate::ff::{Fp31};
+    use crate::ff::{Fp31, RefLocalArithmeticOps};
     use crate::secret_sharing::{Linear, SharedValue};
     use crate::secret_sharing::replicated::{malicious, semi_honest};
-    use crate::secret_sharing::scheme::RefLocalArithmeticOps;
 
     fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L> {
         let a = L::ZERO;
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index 130a80499..0d001726e 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -20,8 +20,6 @@ pub trait Linear<V: SharedValue>: SecretSharing<V>
     + Neg<Output=Self>
 {}
 
-pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> {}
-impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> + 'a {}
 
 /// Secret share of a secret in bits. It has additive and multiplicative properties.
 pub trait Bitwise<V: GaloisField>: SecretSharing<V> + Linear<V> {}

From b6446b2ecc9026395b0b9ba212f77c6026efa05e Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Mon, 25 Sep 2023 17:01:16 -0700
Subject: [PATCH 007/105] Checkpoint for multiplication

---
 src/ff/mod.rs                                   | 17 ++++++++---------
 src/protocol/boolean/solved_bits.rs             |  1 +
 .../replicated/malicious/additive_share.rs      | 12 ++++++++++--
 .../replicated/semi_honest/additive_share.rs    | 10 +++++++++-
 src/secret_sharing/scheme.rs                    |  1 +
 5 files changed, 29 insertions(+), 12 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index bd3a50e5f..5c3727b27 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -23,35 +23,33 @@ pub enum Error {
 
 /// Arithmetic operations that do not require communication in our MPC setting and can be performed
 /// locally.
+///
+/// Note: Neg operation is also local, but is causing issues when added as a bound to this trait.
+/// The problem is that it does not use `Rhs` generic and rustc overflows trying to compile functions
+/// that use HRTB generics bounded by `LocalArithmeticOps`.
 pub trait LocalArithmeticOps<Rhs = Self, Output = Self>:
 Add<Rhs, Output = Output>
-// + AddAssign<Rhs>
 + Sub<Rhs, Output = Output>
-// + SubAssign<Rhs>
-// + Neg<Output = Output>
 + Sized
 {
 }
 
 impl<T, Rhs, Output> LocalArithmeticOps<Rhs, Output> for T where
     T: Add<Rhs, Output = Output>
-    // + AddAssign<Rhs>
     + Sub<Rhs, Output = Output>
-    // + SubAssign<Rhs>
-    // + Neg<Output = Output>
     + Sized {}
 
 
-pub trait LocalAssignOps<Rhs = Self>: AddAssign<Rhs> + SubAssign<Rhs> + Neg<Output = Self> {}
-impl <T, Rhs> LocalAssignOps<Rhs> for T where T:AddAssign<Rhs> + SubAssign<Rhs> + Neg<Output = Self> {}
+pub trait LocalAssignOps<Rhs = Self>: AddAssign<Rhs> + SubAssign<Rhs> {}
+impl <T, Rhs> LocalAssignOps<Rhs> for T where T:AddAssign<Rhs> + SubAssign<Rhs> {}
 
 /// TODO: add docs
 /// May or may not require communication, depending on the value. Multiplying field values is a
 /// local operation, while multiplying secret shares is not.
 pub trait ArithmeticOps<Rhs = Self, Output = Self>: LocalArithmeticOps<Rhs, Output> + LocalAssignOps<Rhs>
-// TODO: make mul a trait and implement it for secret sharing
     + Mul<Rhs, Output = Output>
     + MulAssign<Rhs>
+    + Neg<Output = Output>
 {
 }
 
@@ -59,6 +57,7 @@ impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
     T: LocalArithmeticOps<Rhs, Output> + LocalAssignOps<Rhs>
     + Mul<Rhs, Output = Output>
     + MulAssign<Rhs>
+    + Neg<Output = Output>
 {
 }
 
diff --git a/src/protocol/boolean/solved_bits.rs b/src/protocol/boolean/solved_bits.rs
index 292c24976..545978afc 100644
--- a/src/protocol/boolean/solved_bits.rs
+++ b/src/protocol/boolean/solved_bits.rs
@@ -113,6 +113,7 @@ where
     //
     // if success, then compute `[b_p]` by `Σ 2^i * [b_i]_B`
     let b_p: S = b_b.iter().enumerate().fold(S::ZERO, |acc, (i, x)| {
+        // todo: fix multiplication
         acc + &(x.clone() * F::try_from(1 << i).unwrap())
     });
 
diff --git a/src/secret_sharing/replicated/malicious/additive_share.rs b/src/secret_sharing/replicated/malicious/additive_share.rs
index 183560bbd..d7ebb9ec1 100644
--- a/src/secret_sharing/replicated/malicious/additive_share.rs
+++ b/src/secret_sharing/replicated/malicious/additive_share.rs
@@ -250,10 +250,10 @@ impl<V: SharedValue + ExtendableField> SubAssign<Self> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue + ExtendableField> Mul<V> for AdditiveShare<V> {
+impl<V: SharedValue + ExtendableField> Mul<&V> for AdditiveShare<V> {
     type Output = Self;
 
-    fn mul(self, rhs: V) -> Self::Output {
+    fn mul(self, rhs: &V) -> Self::Output {
         Self {
             x: self.x * rhs,
             rx: self.rx * rhs.to_extended(),
@@ -261,6 +261,14 @@ impl<V: SharedValue + ExtendableField> Mul<V> for AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue + ExtendableField> Mul<V> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn mul(self, rhs: V) -> Self::Output {
+        Mul::mul(self, &rhs)
+    }
+}
+
 /// todo serde macro for these collections so we can hide the crazy size calculations
 impl<V: SharedValue + ExtendableField> Serializable for AdditiveShare<V>
 where
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index 34a063e53..41b97def4 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -181,11 +181,19 @@ impl<V: SharedValue> SubAssign<Self> for AdditiveShare<V> {
     }
 }
 
+impl<V: SharedValue> Mul<&V> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn mul(self, rhs: &V) -> Self::Output {
+        Self(self.0 * *rhs, self.1 * *rhs)
+    }
+}
+
 impl<V: SharedValue> Mul<V> for AdditiveShare<V> {
     type Output = Self;
 
     fn mul(self, rhs: V) -> Self::Output {
-        Self(self.0 * rhs, self.1 * rhs)
+        Mul::mul(self, &rhs)
     }
 }
 
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index 0d001726e..1ea50ecca 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -17,6 +17,7 @@ pub trait Linear<V: SharedValue>: SecretSharing<V>
     + for<'r> LocalAssignOps<&'r Self>
     // TODO: add reference
     + Mul<V, Output=Self>
+    + for<'r> Mul<&'r V, Output = Self>
     + Neg<Output=Self>
 {}
 

From a7c00df747069e4a49fc1b59b75f057d153dd480 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 26 Sep 2023 10:05:19 -0700
Subject: [PATCH 008/105] Multiplication is ready

---
 src/ff/mod.rs                                 | 14 ++++++++--
 .../attribution/apply_attribution_window.rs   |  6 ++--
 src/protocol/attribution/credit_capping.rs    |  8 +++---
 src/protocol/attribution/mod.rs               |  6 ++--
 src/protocol/basics/if_else.rs                |  2 +-
 src/protocol/boolean/bitwise_equal.rs         |  4 +--
 src/protocol/boolean/comparison.rs            |  8 +++---
 src/protocol/boolean/random_bits_generator.rs |  2 ++
 src/protocol/boolean/solved_bits.rs           |  2 ++
 src/protocol/ipa/mod.rs                       |  4 +--
 src/protocol/sort/bit_permutation.rs          |  2 +-
 src/query/runner/ipa.rs                       |  4 +--
 src/secret_sharing/mod.rs                     |  8 +++---
 .../replicated/malicious/additive_share.rs    | 28 +++++++++++++++----
 .../replicated/semi_honest/additive_share.rs  | 22 +++++++++++++--
 15 files changed, 83 insertions(+), 37 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 5c3727b27..e366853bc 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -65,8 +65,18 @@ impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
 /// second operand either by value or by reference.
 ///
 /// This is automatically implemented for types which implement the operators.
-pub trait RefLocalArithmeticOps<'a, Base: 'a>: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> {}
-impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<Base, Base> + LocalArithmeticOps<&'a Base, Base> + 'a {}
+pub trait RefLocalArithmeticOps<'a, Base: 'a, R: 'a>:
+    LocalArithmeticOps<Base, Base>
+    + LocalArithmeticOps<&'a Base, Base>
+    + Mul<R, Output = Base>
+    + Mul<&'a R, Output = Base>
+{}
+impl<'a, T, Base: 'a, R: 'a> RefLocalArithmeticOps<'a, Base, R> for T
+    where T: LocalArithmeticOps<Base, Base>
+    + LocalArithmeticOps<&'a Base, Base> + 'a
+    + Mul<R, Output = Base>
+    + Mul<&'a R, Output = Base>
+{}
 
 // impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<&'a Base, Base> + 'a {}
 
diff --git a/src/protocol/attribution/apply_attribution_window.rs b/src/protocol/attribution/apply_attribution_window.rs
index 845ecc0e3..e35c89201 100644
--- a/src/protocol/attribution/apply_attribution_window.rs
+++ b/src/protocol/attribution/apply_attribution_window.rs
@@ -38,7 +38,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + 'static,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     if let Some(attribution_window_seconds) = attribution_window_seconds {
         let mut t_deltas = prefix_sum_time_deltas(&ctx, input, stop_bits).await?;
@@ -92,7 +92,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a T: RefLocalArithmeticOps<'a, T>,
+    for <'a> &'a T: RefLocalArithmeticOps<'a, T, F>,
 {
     let num_rows = input.len();
 
@@ -152,7 +152,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     let ctx = ctx.set_total_records(input.len());
     let random_bits_generator =
diff --git a/src/protocol/attribution/credit_capping.rs b/src/protocol/attribution/credit_capping.rs
index 3b2bad98d..4a398f73c 100644
--- a/src/protocol/attribution/credit_capping.rs
+++ b/src/protocol/attribution/credit_capping.rs
@@ -36,7 +36,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     if cap == 1 {
         return Ok(credit_capping_max_one(ctx, input)
@@ -243,7 +243,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     let share_of_cap = S::share_known_value(&ctx, F::truncate_from(cap));
     let cap_ref = &share_of_cap;
@@ -298,7 +298,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(prefix_summed_credits.len());
@@ -361,7 +361,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a T: RefLocalArithmeticOps<'a, T>
+    for <'a> &'a T: RefLocalArithmeticOps<'a, T, F>
 {
     let num_rows = input.len();
     let cap_share = T::share_known_value(&ctx, F::try_from(cap.into()).unwrap());
diff --git a/src/protocol/attribution/mod.rs b/src/protocol/attribution/mod.rs
index d3b93ff8d..666783afe 100644
--- a/src/protocol/attribution/mod.rs
+++ b/src/protocol/attribution/mod.rs
@@ -63,13 +63,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB> + Context,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for <'a> &'a SB: RefLocalArithmeticOps<'a, SB>,
+    for <'a> &'a SB: RefLocalArithmeticOps<'a, SB, Gf2>,
     F: PrimeField + ExtendableField,
     ShuffledPermutationWrapper<S, C::UpgradedContext<F>>: DowngradeMalicious<Target = Vec<u32>>,
 {
@@ -406,7 +406,7 @@ async fn compute_helper_bits_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>
 {
     let narrowed_ctx = ctx
         .narrow(&Step::ComputeHelperBits)
diff --git a/src/protocol/basics/if_else.rs b/src/protocol/basics/if_else.rs
index cf8a9ed70..88e054096 100644
--- a/src/protocol/basics/if_else.rs
+++ b/src/protocol/basics/if_else.rs
@@ -20,7 +20,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + SecureMul<C>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     // If `condition` is a share of 1 (true), then
     //   = false_value + 1 * (true_value - false_value)
diff --git a/src/protocol/boolean/bitwise_equal.rs b/src/protocol/boolean/bitwise_equal.rs
index 7bff2a07a..63907af21 100644
--- a/src/protocol/boolean/bitwise_equal.rs
+++ b/src/protocol/boolean/bitwise_equal.rs
@@ -25,7 +25,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     assert!(a.len() <= 128);
 
@@ -58,7 +58,7 @@ pub async fn bitwise_equal_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>
 {
     debug_assert!(a.len() == b.len());
     let c = zip(a.iter(), b.iter())
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 0b95533d5..1d8105d28 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -74,7 +74,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     use GreaterThanConstantStep as Step;
 
@@ -176,7 +176,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     assert!(a.len() <= 128);
 
@@ -209,7 +209,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     assert!(a.len() <= 128);
 
@@ -240,7 +240,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S>
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     let one = S::share_known_value(ctx, F::ONE);
 
diff --git a/src/protocol/boolean/random_bits_generator.rs b/src/protocol/boolean/random_bits_generator.rs
index 51fd7bf38..4a47c5658 100644
--- a/src/protocol/boolean/random_bits_generator.rs
+++ b/src/protocol/boolean/random_bits_generator.rs
@@ -16,6 +16,7 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 /// A struct that generates random sharings of bits from the
 /// `SolvedBits` protocol. Any protocol who wish to use a random-bits can draw
@@ -44,6 +45,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     #[must_use]
     pub fn new(ctx: C) -> Self {
diff --git a/src/protocol/boolean/solved_bits.rs b/src/protocol/boolean/solved_bits.rs
index 545978afc..6658d7c8a 100644
--- a/src/protocol/boolean/solved_bits.rs
+++ b/src/protocol/boolean/solved_bits.rs
@@ -21,6 +21,7 @@ use crate::{
         BitDecomposed, Linear as LinearSecretSharing, SecretSharing,
     },
 };
+use crate::ff::RefLocalArithmeticOps;
 
 #[derive(Debug)]
 pub struct RandomBitsShare<F, S>
@@ -94,6 +95,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     //
     // step 1 & 2
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index acec56801..6e60c39fe 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -316,13 +316,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for <'r> &'r S: RefLocalArithmeticOps<'r, S>,
+    for <'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB>,
+    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
     F: PrimeField + ExtendableField,
     MK: GaloisField,
     BK: GaloisField,
diff --git a/src/protocol/sort/bit_permutation.rs b/src/protocol/sort/bit_permutation.rs
index 2523378e4..013042d64 100644
--- a/src/protocol/sort/bit_permutation.rs
+++ b/src/protocol/sort/bit_permutation.rs
@@ -41,7 +41,7 @@ pub async fn bit_permutation<
     ctx: C,
     input: &[S],
 ) -> Result<Vec<S>, Error>
-    where for<'r> &'r S: RefLocalArithmeticOps<'r, S> {
+    where for<'r> &'r S: RefLocalArithmeticOps<'r, S, F> {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(2 * input.len());
     let share_of_one = S::share_known_value(&ctx, F::ONE);
diff --git a/src/query/runner/ipa.rs b/src/query/runner/ipa.rs
index b4a652cd1..0a5d50309 100644
--- a/src/query/runner/ipa.rs
+++ b/src/query/runner/ipa.rs
@@ -56,13 +56,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for <'r> &'r S: RefLocalArithmeticOps<'r, S>,
+    for <'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB>,
+    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
     F: PrimeField,
     Replicated<F>: Serializable + ShareKnownValue<C, F>,
     IPAInputRow<F, MatchKey, BreakdownKey>: Serializable,
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 279a65829..66bafa9c5 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -63,7 +63,7 @@ mod tests {
     use crate::secret_sharing::{Linear, SharedValue};
     use crate::secret_sharing::replicated::{malicious, semi_honest};
 
-    fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L> {
+    fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L, V> {
         let a = L::ZERO;
         let b = L::ZERO;
 
@@ -73,13 +73,13 @@ mod tests {
         assert_eq!(L::ZERO, a + b);
     }
 
-    fn trait_bounds<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L> {
+    fn trait_bounds<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L, V> {
 
         fn sum_owned<S: Linear<V>, V: SharedValue>(a: S, b: S) -> S {
             a + b
         }
 
-        fn sum_ref_ref<S, V>(a: &S, b: &S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S> {
+        fn sum_ref_ref<S, V>(a: &S, b: &S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S, V> {
             a + b
         }
 
@@ -87,7 +87,7 @@ mod tests {
             a + b
         }
 
-        fn sum_ref_owned<S, V>(a: &S, b: S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S> {
+        fn sum_ref_owned<S, V>(a: &S, b: S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S, V> {
             a + b
         }
 
diff --git a/src/secret_sharing/replicated/malicious/additive_share.rs b/src/secret_sharing/replicated/malicious/additive_share.rs
index d7ebb9ec1..bbb412769 100644
--- a/src/secret_sharing/replicated/malicious/additive_share.rs
+++ b/src/secret_sharing/replicated/malicious/additive_share.rs
@@ -250,13 +250,13 @@ impl<V: SharedValue + ExtendableField> SubAssign<Self> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue + ExtendableField> Mul<&V> for AdditiveShare<V> {
-    type Output = Self;
+impl<'a, 'b, V: SharedValue + ExtendableField> Mul<&'b V> for &'a AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
 
-    fn mul(self, rhs: &V) -> Self::Output {
-        Self {
-            x: self.x * rhs,
-            rx: self.rx * rhs.to_extended(),
+    fn mul(self, rhs: &'b V) -> Self::Output {
+        AdditiveShare {
+            x: &self.x * rhs,
+            rx: &self.rx * &rhs.to_extended()
         }
     }
 }
@@ -264,6 +264,22 @@ impl<V: SharedValue + ExtendableField> Mul<&V> for AdditiveShare<V> {
 impl<V: SharedValue + ExtendableField> Mul<V> for AdditiveShare<V> {
     type Output = Self;
 
+    fn mul(self, rhs: V) -> Self::Output {
+        Mul::mul(&self, &rhs)
+    }
+}
+
+impl<V: SharedValue + ExtendableField> Mul<&V> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn mul(self, rhs: &V) -> Self::Output {
+        Mul::mul(&self, rhs)
+    }
+}
+
+impl<V: SharedValue + ExtendableField> Mul<V> for &AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
+
     fn mul(self, rhs: V) -> Self::Output {
         Mul::mul(self, &rhs)
     }
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index 41b97def4..c4daa655c 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -181,16 +181,32 @@ impl<V: SharedValue> SubAssign<Self> for AdditiveShare<V> {
     }
 }
 
+impl<'a, 'b, V: SharedValue> Mul<&'b V> for &'a AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
+
+    fn mul(self, rhs: &'b V) -> Self::Output {
+        AdditiveShare(self.0 * *rhs, self.1 * *rhs)
+    }
+}
+
+impl<V: SharedValue> Mul<V> for AdditiveShare<V> {
+    type Output = Self;
+
+    fn mul(self, rhs: V) -> Self::Output {
+        Mul::mul(&self, &rhs)
+    }
+}
+
 impl<V: SharedValue> Mul<&V> for AdditiveShare<V> {
     type Output = Self;
 
     fn mul(self, rhs: &V) -> Self::Output {
-        Self(self.0 * *rhs, self.1 * *rhs)
+        Mul::mul(&self, rhs)
     }
 }
 
-impl<V: SharedValue> Mul<V> for AdditiveShare<V> {
-    type Output = Self;
+impl<V: SharedValue> Mul<V> for &AdditiveShare<V> {
+    type Output = AdditiveShare<V>;
 
     fn mul(self, rhs: V) -> Self::Output {
         Mul::mul(self, &rhs)

From c9fff40e9c0361a4c2183b5956f76e44542e80c0 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 26 Sep 2023 10:33:07 -0700
Subject: [PATCH 009/105] Remove clone calls on multiplications

---
 src/protocol/boolean/add_constant.rs | 7 +++++--
 src/protocol/boolean/solved_bits.rs  | 3 +--
 src/protocol/context/malicious.rs    | 2 +-
 src/secret_sharing/decomposed.rs     | 2 +-
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/protocol/boolean/add_constant.rs b/src/protocol/boolean/add_constant.rs
index e6104cd5d..6d4422f1f 100644
--- a/src/protocol/boolean/add_constant.rs
+++ b/src/protocol/boolean/add_constant.rs
@@ -4,6 +4,7 @@ use crate::{
     protocol::{context::Context, step::BitOpStep, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::ff::RefLocalArithmeticOps;
 
 /// This is an implementation of a Bitwise Sum of a bitwise-shared number with a constant.
 ///
@@ -52,6 +53,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
+    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
 {
     let mut output = Vec::with_capacity(a.len() + 1);
 
@@ -67,6 +69,7 @@ where
         S::share_known_value(&ctx, F::ONE) - &a[0]
     };
     output.push(result_bit);
+    let two = F::truncate_from(2_u8);
 
     for (bit_index, bit) in a.iter().enumerate().skip(1) {
         let mult_result = if last_carry_known_to_be_zero {
@@ -94,12 +97,12 @@ where
         // the current bit of `a` + the current bit of `b` + the carry from the previous bit `-2*next_carry`
         // Since the current bit of `b` has a known value (either 1 or 0), we either add a `share_of_one`, or nothing.
         let result_bit = if next_bit_a_one {
-            -next_carry.clone() * F::truncate_from(2_u128)
+            -(&next_carry * &two)
                 + &S::share_known_value(&ctx, F::ONE)
                 + bit
                 + &last_carry
         } else {
-            -next_carry.clone() * F::truncate_from(2_u128) + bit + &last_carry
+            -(&next_carry * &two) + bit + &last_carry
         };
         output.push(result_bit);
 
diff --git a/src/protocol/boolean/solved_bits.rs b/src/protocol/boolean/solved_bits.rs
index 6658d7c8a..9e889879b 100644
--- a/src/protocol/boolean/solved_bits.rs
+++ b/src/protocol/boolean/solved_bits.rs
@@ -115,8 +115,7 @@ where
     //
     // if success, then compute `[b_p]` by `Σ 2^i * [b_i]_B`
     let b_p: S = b_b.iter().enumerate().fold(S::ZERO, |acc, (i, x)| {
-        // todo: fix multiplication
-        acc + &(x.clone() * F::try_from(1 << i).unwrap())
+        acc + &(x * F::try_from(1 << i).unwrap())
     });
 
     Ok(Some(RandomBitsShare {
diff --git a/src/protocol/context/malicious.rs b/src/protocol/context/malicious.rs
index 2338f96a1..bc4fc0282 100644
--- a/src/protocol/context/malicious.rs
+++ b/src/protocol/context/malicious.rs
@@ -199,7 +199,7 @@ impl<'a, F: ExtendableField> UpgradedContext<F> for Upgraded<'a, F> {
     fn share_known_value(&self, value: F) -> MaliciousReplicated<F> {
         MaliciousReplicated::new(
             Replicated::share_known_value(&self.clone().base_context(), value),
-            self.inner.r_share.clone() * value.to_extended(),
+            &self.inner.r_share * value.to_extended(),
         )
     }
 
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 139c34d01..f415633fe 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -59,7 +59,7 @@ impl<S> BitDecomposed<S> {
         F: PrimeField,
     {
         self.iter().enumerate().fold(S::ZERO, |acc, (i, b)| {
-            acc + &(b.clone() * F::truncate_from(1_u128 << i))
+            acc + (b * F::truncate_from(1_u128 << i))
         })
     }
 }

From 91e570865f2b26e2fa7dbc33c9d790c83580f134 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 26 Sep 2023 10:52:31 -0700
Subject: [PATCH 010/105] Clippy + formatting

---
 src/ff/mod.rs                                 | 67 +++++++------------
 src/protocol/aggregation/mod.rs               |  4 +-
 .../attribution/apply_attribution_window.rs   |  9 ++-
 src/protocol/attribution/credit_capping.rs    | 11 ++-
 src/protocol/attribution/mod.rs               |  9 ++-
 src/protocol/basics/if_else.rs                |  5 +-
 src/protocol/boolean/add_constant.rs          | 12 ++--
 src/protocol/boolean/bitwise_equal.rs         |  7 +-
 src/protocol/boolean/comparison.rs            | 11 ++-
 src/protocol/boolean/random_bits_generator.rs |  5 +-
 src/protocol/boolean/solved_bits.rs           |  5 +-
 src/protocol/ipa/mod.rs                       |  7 +-
 src/protocol/sort/bit_permutation.rs          |  7 +-
 src/query/runner/aggregate.rs                 |  3 +-
 src/query/runner/ipa.rs                       |  7 +-
 src/secret_sharing/decomposed.rs              |  7 +-
 src/secret_sharing/mod.rs                     | 40 ++++++++---
 .../replicated/malicious/additive_share.rs    |  6 +-
 .../replicated/semi_honest/additive_share.rs  |  4 +-
 src/secret_sharing/scheme.rs                  |  7 +-
 20 files changed, 113 insertions(+), 120 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index e366853bc..2622d6631 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -28,25 +28,24 @@ pub enum Error {
 /// The problem is that it does not use `Rhs` generic and rustc overflows trying to compile functions
 /// that use HRTB generics bounded by `LocalArithmeticOps`.
 pub trait LocalArithmeticOps<Rhs = Self, Output = Self>:
-Add<Rhs, Output = Output>
-+ Sub<Rhs, Output = Output>
-+ Sized
+    Add<Rhs, Output = Output> + Sub<Rhs, Output = Output> + Sized
 {
 }
 
 impl<T, Rhs, Output> LocalArithmeticOps<Rhs, Output> for T where
-    T: Add<Rhs, Output = Output>
-    + Sub<Rhs, Output = Output>
-    + Sized {}
-
+    T: Add<Rhs, Output = Output> + Sub<Rhs, Output = Output> + Sized
+{
+}
 
 pub trait LocalAssignOps<Rhs = Self>: AddAssign<Rhs> + SubAssign<Rhs> {}
-impl <T, Rhs> LocalAssignOps<Rhs> for T where T:AddAssign<Rhs> + SubAssign<Rhs> {}
+impl<T, Rhs> LocalAssignOps<Rhs> for T where T: AddAssign<Rhs> + SubAssign<Rhs> {}
 
 /// TODO: add docs
 /// May or may not require communication, depending on the value. Multiplying field values is a
 /// local operation, while multiplying secret shares is not.
-pub trait ArithmeticOps<Rhs = Self, Output = Self>: LocalArithmeticOps<Rhs, Output> + LocalAssignOps<Rhs>
+pub trait ArithmeticOps<Rhs = Self, Output = Self>:
+    LocalArithmeticOps<Rhs, Output>
+    + LocalAssignOps<Rhs>
     + Mul<Rhs, Output = Output>
     + MulAssign<Rhs>
     + Neg<Output = Output>
@@ -54,10 +53,11 @@ pub trait ArithmeticOps<Rhs = Self, Output = Self>: LocalArithmeticOps<Rhs, Outp
 }
 
 impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
-    T: LocalArithmeticOps<Rhs, Output> + LocalAssignOps<Rhs>
-    + Mul<Rhs, Output = Output>
-    + MulAssign<Rhs>
-    + Neg<Output = Output>
+    T: LocalArithmeticOps<Rhs, Output>
+        + LocalAssignOps<Rhs>
+        + Mul<Rhs, Output = Output>
+        + MulAssign<Rhs>
+        + Neg<Output = Output>
 {
 }
 
@@ -70,37 +70,16 @@ pub trait RefLocalArithmeticOps<'a, Base: 'a, R: 'a>:
     + LocalArithmeticOps<&'a Base, Base>
     + Mul<R, Output = Base>
     + Mul<&'a R, Output = Base>
-{}
-impl<'a, T, Base: 'a, R: 'a> RefLocalArithmeticOps<'a, Base, R> for T
-    where T: LocalArithmeticOps<Base, Base>
-    + LocalArithmeticOps<&'a Base, Base> + 'a
-    + Mul<R, Output = Base>
-    + Mul<&'a R, Output = Base>
-{}
-
-// impl<'a, T, Base: 'a> RefLocalArithmeticOps<'a, Base> for T where T: LocalArithmeticOps<&'a Base, Base> + 'a {}
-
-// pub trait ArithmeticRefOps<V: SharedValue>:
-//     for<'a> Add<&'a Self, Output = Self>
-//     + for<'a> AddAssign<&'a Self>
-//     + Neg<Output = Self>
-//     + for<'a> Sub<&'a Self, Output = Self>
-//     + for<'a> SubAssign<&'a Self>
-//     + Mul<V, Output = Self>
-// {
-// }
-//
-// impl<T, V> ArithmeticRefOps<V> for T
-// where
-//     T: for<'a> Add<&'a Self, Output = Self>
-//         + for<'a> AddAssign<&'a Self>
-//         + Neg<Output = Self>
-//         + for<'a> Sub<&'a Self, Output = Self>
-//         + for<'a> SubAssign<&'a Self>
-//         + Mul<V, Output = Self>,
-//     V: SharedValue,
-// {
-// }
+{
+}
+impl<'a, T, Base: 'a, R: 'a> RefLocalArithmeticOps<'a, Base, R> for T where
+    T: LocalArithmeticOps<Base, Base>
+        + LocalArithmeticOps<&'a Base, Base>
+        + 'a
+        + Mul<R, Output = Base>
+        + Mul<&'a R, Output = Base>
+{
+}
 
 /// Trait for items that have fixed-byte length representation.
 pub trait Serializable: Sized {
diff --git a/src/protocol/aggregation/mod.rs b/src/protocol/aggregation/mod.rs
index 202560975..9fbf55453 100644
--- a/src/protocol/aggregation/mod.rs
+++ b/src/protocol/aggregation/mod.rs
@@ -7,7 +7,7 @@ pub use input::SparseAggregateInputRow;
 use super::{context::Context, sort::bitwise_to_onehot, step::BitOpStep, RecordId};
 use crate::{
     error::Error,
-    ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
+    ff::{Field, GaloisField, Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
     protocol::{
         context::{UpgradableContext, UpgradedContext, Validator},
         modulus_conversion::convert_bits,
@@ -76,6 +76,7 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
+    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2> + BasicProtocols<C::UpgradedContext<Gf2>, Gf2> + 'static,
     F: PrimeField + ExtendableField,
@@ -130,6 +131,7 @@ where
     I2: Stream<Item = Result<BitDecomposed<S>, Error>> + Send,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + Serializable + 'static,
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     let equality_check_ctx = ctx.narrow(&Step::ComputeEqualityChecks);
 
diff --git a/src/protocol/attribution/apply_attribution_window.rs b/src/protocol/attribution/apply_attribution_window.rs
index e35c89201..3c216c703 100644
--- a/src/protocol/attribution/apply_attribution_window.rs
+++ b/src/protocol/attribution/apply_attribution_window.rs
@@ -11,7 +11,7 @@ use super::{
 };
 use crate::{
     error::Error,
-    ff::{Field, PrimeField},
+    ff::{Field, PrimeField, RefLocalArithmeticOps},
     protocol::{
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
         context::{Context, UpgradedContext},
@@ -19,7 +19,6 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 /// This protocol applies the specified attribution window to trigger events. All trigger values of
 /// events that are outside the window will be replaced with 0, hence will not be attributed to
@@ -38,7 +37,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + 'static,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     if let Some(attribution_window_seconds) = attribution_window_seconds {
         let mut t_deltas = prefix_sum_time_deltas(&ctx, input, stop_bits).await?;
@@ -92,7 +91,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a T: RefLocalArithmeticOps<'a, T, F>,
+    for<'a> &'a T: RefLocalArithmeticOps<'a, T, F>,
 {
     let num_rows = input.len();
 
@@ -152,7 +151,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     let ctx = ctx.set_total_records(input.len());
     let random_bits_generator =
diff --git a/src/protocol/attribution/credit_capping.rs b/src/protocol/attribution/credit_capping.rs
index 4a398f73c..c278b76c2 100644
--- a/src/protocol/attribution/credit_capping.rs
+++ b/src/protocol/attribution/credit_capping.rs
@@ -9,7 +9,7 @@ use ipa_macros::Step;
 use super::{do_the_binary_tree_thing, input::CreditCappingInputRow, prefix_or_binary_tree_style};
 use crate::{
     error::Error,
-    ff::{Field, PrimeField},
+    ff::{Field, PrimeField, RefLocalArithmeticOps},
     protocol::{
         basics::{if_else, SecureMul},
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
@@ -19,7 +19,6 @@ use crate::{
     secret_sharing::Linear as LinearSecretSharing,
     seq_join::seq_join,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 /// User-level credit capping protocol.
 ///
@@ -36,7 +35,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     if cap == 1 {
         return Ok(credit_capping_max_one(ctx, input)
@@ -243,7 +242,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     let share_of_cap = S::share_known_value(&ctx, F::truncate_from(cap));
     let cap_ref = &share_of_cap;
@@ -298,7 +297,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(prefix_summed_credits.len());
@@ -361,7 +360,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a T: RefLocalArithmeticOps<'a, T, F>
+    for<'a> &'a T: RefLocalArithmeticOps<'a, T, F>,
 {
     let num_rows = input.len();
     let cap_share = T::share_known_value(&ctx, F::try_from(cap.into()).unwrap());
diff --git a/src/protocol/attribution/mod.rs b/src/protocol/attribution/mod.rs
index 666783afe..50ad92e63 100644
--- a/src/protocol/attribution/mod.rs
+++ b/src/protocol/attribution/mod.rs
@@ -19,7 +19,7 @@ use self::{
 };
 use crate::{
     error::Error,
-    ff::{Field, Gf2, PrimeField, Serializable},
+    ff::{Field, Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
     helpers::query::IpaQueryConfig,
     protocol::{
         basics::SecureMul,
@@ -39,7 +39,6 @@ use crate::{
     },
     seq_join::assert_send,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 /// Performs a set of attribution protocols on the sorted IPA input.
 ///
@@ -63,13 +62,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB> + Context,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for <'a> &'a SB: RefLocalArithmeticOps<'a, SB, Gf2>,
+    for<'a> &'a SB: RefLocalArithmeticOps<'a, SB, Gf2>,
     F: PrimeField + ExtendableField,
     ShuffledPermutationWrapper<S, C::UpgradedContext<F>>: DowngradeMalicious<Target = Vec<u32>>,
 {
@@ -406,7 +405,7 @@ async fn compute_helper_bits_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>,
 {
     let narrowed_ctx = ctx
         .narrow(&Step::ComputeHelperBits)
diff --git a/src/protocol/basics/if_else.rs b/src/protocol/basics/if_else.rs
index 88e054096..85e7e0685 100644
--- a/src/protocol/basics/if_else.rs
+++ b/src/protocol/basics/if_else.rs
@@ -1,10 +1,9 @@
 use crate::{
     error::Error,
-    ff::Field,
+    ff::{Field, RefLocalArithmeticOps},
     protocol::{basics::SecureMul, context::Context, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 /// Returns `true_value` if `condition` is a share of 1, else `false_value`.
 /// # Errors
@@ -20,7 +19,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + SecureMul<C>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     // If `condition` is a share of 1 (true), then
     //   = false_value + 1 * (true_value - false_value)
diff --git a/src/protocol/boolean/add_constant.rs b/src/protocol/boolean/add_constant.rs
index 6d4422f1f..004aebd12 100644
--- a/src/protocol/boolean/add_constant.rs
+++ b/src/protocol/boolean/add_constant.rs
@@ -1,10 +1,9 @@
 use crate::{
     error::Error,
-    ff::Field,
+    ff::{Field, RefLocalArithmeticOps},
     protocol::{context::Context, step::BitOpStep, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 /// This is an implementation of a Bitwise Sum of a bitwise-shared number with a constant.
 ///
@@ -53,7 +52,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     let mut output = Vec::with_capacity(a.len() + 1);
 
@@ -97,12 +96,9 @@ where
         // the current bit of `a` + the current bit of `b` + the carry from the previous bit `-2*next_carry`
         // Since the current bit of `b` has a known value (either 1 or 0), we either add a `share_of_one`, or nothing.
         let result_bit = if next_bit_a_one {
-            -(&next_carry * &two)
-                + &S::share_known_value(&ctx, F::ONE)
-                + bit
-                + &last_carry
+            -(&next_carry * two) + &S::share_known_value(&ctx, F::ONE) + bit + &last_carry
         } else {
-            -(&next_carry * &two) + bit + &last_carry
+            -(&next_carry * two) + bit + &last_carry
         };
         output.push(result_bit);
 
diff --git a/src/protocol/boolean/bitwise_equal.rs b/src/protocol/boolean/bitwise_equal.rs
index 63907af21..2d29d858d 100644
--- a/src/protocol/boolean/bitwise_equal.rs
+++ b/src/protocol/boolean/bitwise_equal.rs
@@ -2,11 +2,10 @@ use std::iter::zip;
 
 use crate::{
     error::Error,
-    ff::{Field, Gf2},
+    ff::{Field, Gf2, RefLocalArithmeticOps},
     protocol::{boolean::all_zeroes, context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 /// Compares `[a]` and `c`, and returns 1 iff `a == c`
 ///
@@ -25,7 +24,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -58,7 +57,7 @@ pub async fn bitwise_equal_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>,
 {
     debug_assert!(a.len() == b.len());
     let c = zip(a.iter(), b.iter())
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 1d8105d28..4f40b5096 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -3,7 +3,7 @@ use ipa_macros::Step;
 use super::or::or;
 use crate::{
     error::Error,
-    ff::PrimeField,
+    ff::{PrimeField, RefLocalArithmeticOps},
     protocol::{
         boolean::random_bits_generator::RandomBitsGenerator,
         context::{Context, UpgradedContext},
@@ -12,7 +12,6 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 // Compare an arithmetic-shared value `a` to a known value `c`.
 //
@@ -74,7 +73,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     use GreaterThanConstantStep as Step;
 
@@ -176,7 +175,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -209,7 +208,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -240,7 +239,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     let one = S::share_known_value(ctx, F::ONE);
 
diff --git a/src/protocol/boolean/random_bits_generator.rs b/src/protocol/boolean/random_bits_generator.rs
index 4a47c5658..481330cb1 100644
--- a/src/protocol/boolean/random_bits_generator.rs
+++ b/src/protocol/boolean/random_bits_generator.rs
@@ -7,7 +7,7 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::PrimeField,
+    ff::{PrimeField, RefLocalArithmeticOps},
     helpers::TotalRecords,
     protocol::{
         boolean::solved_bits::{solved_bits, RandomBitsShare},
@@ -16,7 +16,6 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 /// A struct that generates random sharings of bits from the
 /// `SolvedBits` protocol. Any protocol who wish to use a random-bits can draw
@@ -45,7 +44,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     #[must_use]
     pub fn new(ctx: C) -> Self {
diff --git a/src/protocol/boolean/solved_bits.rs b/src/protocol/boolean/solved_bits.rs
index 9e889879b..4359d1134 100644
--- a/src/protocol/boolean/solved_bits.rs
+++ b/src/protocol/boolean/solved_bits.rs
@@ -5,7 +5,7 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{Field, PrimeField},
+    ff::{Field, PrimeField, RefLocalArithmeticOps},
     protocol::{
         boolean::{
             bitwise_less_than_prime::BitwiseLessThanPrime, generate_random_bits::one_random_bit,
@@ -21,7 +21,6 @@ use crate::{
         BitDecomposed, Linear as LinearSecretSharing, SecretSharing,
     },
 };
-use crate::ff::RefLocalArithmeticOps;
 
 #[derive(Debug)]
 pub struct RandomBitsShare<F, S>
@@ -95,7 +94,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for <'a> &'a S: RefLocalArithmeticOps<'a, S, F>
+    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
 {
     //
     // step 1 & 2
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index 6e60c39fe..735246668 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -11,7 +11,7 @@ use typenum::Unsigned;
 
 use crate::{
     error::Error,
-    ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
+    ff::{Field, GaloisField, Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
     helpers::{query::IpaQueryConfig, Role},
     protocol::{
         attribution::secure_attribution,
@@ -38,7 +38,6 @@ use crate::{
         BitDecomposed, Linear as LinearSecretSharing,
     },
 };
-use crate::ff::RefLocalArithmeticOps;
 
 #[derive(Step)]
 pub(crate) enum Step {
@@ -316,13 +315,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for <'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
+    for<'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
     F: PrimeField + ExtendableField,
     MK: GaloisField,
     BK: GaloisField,
diff --git a/src/protocol/sort/bit_permutation.rs b/src/protocol/sort/bit_permutation.rs
index 013042d64..de9b28bac 100644
--- a/src/protocol/sort/bit_permutation.rs
+++ b/src/protocol/sort/bit_permutation.rs
@@ -4,11 +4,10 @@ use embed_doc_image::embed_doc_image;
 
 use crate::{
     error::Error,
-    ff::Field,
+    ff::{Field, RefLocalArithmeticOps},
     protocol::{context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 #[embed_doc_image("bit_permutation", "images/sort/bit_permutations.png")]
 /// This is an implementation of `GenBitPerm` (Algorithm 3) described in:
@@ -41,7 +40,9 @@ pub async fn bit_permutation<
     ctx: C,
     input: &[S],
 ) -> Result<Vec<S>, Error>
-    where for<'r> &'r S: RefLocalArithmeticOps<'r, S, F> {
+where
+    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+{
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(2 * input.len());
     let share_of_one = S::share_known_value(&ctx, F::ONE);
diff --git a/src/query/runner/aggregate.rs b/src/query/runner/aggregate.rs
index f25abff10..9ab98c15a 100644
--- a/src/query/runner/aggregate.rs
+++ b/src/query/runner/aggregate.rs
@@ -5,7 +5,7 @@ use futures_util::TryStreamExt;
 use super::ipa::assert_stream_send;
 use crate::{
     error::Error,
-    ff::{Gf2, Gf8Bit, PrimeField, Serializable},
+    ff::{Gf2, Gf8Bit, PrimeField, RefLocalArithmeticOps, Serializable},
     helpers::{
         query::{QuerySize, SparseAggregateQueryConfig},
         BodyStream, RecordsStream,
@@ -53,6 +53,7 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
+    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
diff --git a/src/query/runner/ipa.rs b/src/query/runner/ipa.rs
index 0a5d50309..4f2ac3921 100644
--- a/src/query/runner/ipa.rs
+++ b/src/query/runner/ipa.rs
@@ -7,7 +7,7 @@ use futures::{
 
 use crate::{
     error::Error,
-    ff::{Gf2, PrimeField, Serializable},
+    ff::{Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
     helpers::{
         query::{IpaQueryConfig, QuerySize},
         BodyStream, LengthDelimitedStream, RecordsStream,
@@ -28,7 +28,6 @@ use crate::{
     },
     sync::Arc,
 };
-use crate::ff::RefLocalArithmeticOps;
 
 pub struct IpaQuery<F, C, S> {
     config: IpaQueryConfig,
@@ -56,13 +55,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for <'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for <'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
+    for<'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
     F: PrimeField,
     Replicated<F>: Serializable + ShareKnownValue<C, F>,
     IPAInputRow<F, MatchKey, BreakdownKey>: Serializable,
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index f415633fe..5cd64e6e9 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -1,6 +1,10 @@
 use std::{fmt::Debug, ops::Deref};
 
-use crate::{error::Error, ff::PrimeField, secret_sharing::Linear as LinearSecretSharing};
+use crate::{
+    error::Error,
+    ff::{PrimeField, RefLocalArithmeticOps},
+    secret_sharing::Linear as LinearSecretSharing,
+};
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct BitDecomposed<S> {
@@ -56,6 +60,7 @@ impl<S> BitDecomposed<S> {
     pub fn to_additive_sharing_in_large_field<F>(&self) -> S
     where
         S: LinearSecretSharing<F>,
+        for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
         F: PrimeField,
     {
         self.iter().enumerate().fold(S::ZERO, |acc, (i, b)| {
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 66bafa9c5..a1dd93061 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -56,14 +56,20 @@ where
     }
 }
 
-
 #[cfg(all(test, unit_test))]
 mod tests {
-    use crate::ff::{Fp31, RefLocalArithmeticOps};
-    use crate::secret_sharing::{Linear, SharedValue};
-    use crate::secret_sharing::replicated::{malicious, semi_honest};
-
-    fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L, V> {
+    use crate::{
+        ff::{Fp31, RefLocalArithmeticOps},
+        secret_sharing::{
+            replicated::{malicious, semi_honest},
+            Linear, SharedValue,
+        },
+    };
+
+    fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>()
+    where
+        for<'a> &'a L: RefLocalArithmeticOps<'a, L, V>,
+    {
         let a = L::ZERO;
         let b = L::ZERO;
 
@@ -73,13 +79,20 @@ mod tests {
         assert_eq!(L::ZERO, a + b);
     }
 
-    fn trait_bounds<L: Linear<V> + PartialEq, V: SharedValue>() where for <'a> &'a L: RefLocalArithmeticOps<'a, L, V> {
-
+    fn trait_bounds<L: Linear<V> + PartialEq, V: SharedValue>()
+    where
+        for<'a> &'a L: RefLocalArithmeticOps<'a, L, V>,
+    {
         fn sum_owned<S: Linear<V>, V: SharedValue>(a: S, b: S) -> S {
             a + b
         }
 
-        fn sum_ref_ref<S, V>(a: &S, b: &S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S, V> {
+        fn sum_ref_ref<S, V>(a: &S, b: &S) -> S
+        where
+            S: Linear<V>,
+            V: SharedValue,
+            for<'a> &'a S: RefLocalArithmeticOps<'a, S, V>,
+        {
             a + b
         }
 
@@ -87,14 +100,19 @@ mod tests {
             a + b
         }
 
-        fn sum_ref_owned<S, V>(a: &S, b: S) -> S where S: Linear<V>, V: SharedValue, for <'a> &'a S: RefLocalArithmeticOps<'a, S, V> {
+        fn sum_ref_owned<S, V>(a: &S, b: S) -> S
+        where
+            S: Linear<V>,
+            V: SharedValue,
+            for<'a> &'a S: RefLocalArithmeticOps<'a, S, V>,
+        {
             a + b
         }
 
         assert_eq!(L::ZERO, sum_owned(L::ZERO, L::ZERO));
         assert_eq!(L::ZERO, sum_ref_ref(&L::ZERO, &L::ZERO));
         assert_eq!(L::ZERO, sum_owned_ref(L::ZERO, &L::ZERO));
-        assert_eq!(L::ZERO, sum_ref_owned(&L::ZERO, L::ZERO))
+        assert_eq!(L::ZERO, sum_ref_owned(&L::ZERO, L::ZERO));
     }
 
     #[test]
diff --git a/src/secret_sharing/replicated/malicious/additive_share.rs b/src/secret_sharing/replicated/malicious/additive_share.rs
index bbb412769..025590193 100644
--- a/src/secret_sharing/replicated/malicious/additive_share.rs
+++ b/src/secret_sharing/replicated/malicious/additive_share.rs
@@ -187,7 +187,7 @@ impl<V: SharedValue + ExtendableField> AddAssign<&Self> for AdditiveShare<V> {
 
 impl<V: SharedValue + ExtendableField> AddAssign<Self> for AdditiveShare<V> {
     fn add_assign(&mut self, rhs: Self) {
-        AddAssign::add_assign(self, &rhs)
+        AddAssign::add_assign(self, &rhs);
     }
 }
 
@@ -246,7 +246,7 @@ impl<V: SharedValue + ExtendableField> SubAssign<&Self> for AdditiveShare<V> {
 
 impl<V: SharedValue + ExtendableField> SubAssign<Self> for AdditiveShare<V> {
     fn sub_assign(&mut self, rhs: Self) {
-        SubAssign::sub_assign(self, &rhs)
+        SubAssign::sub_assign(self, &rhs);
     }
 }
 
@@ -256,7 +256,7 @@ impl<'a, 'b, V: SharedValue + ExtendableField> Mul<&'b V> for &'a AdditiveShare<
     fn mul(self, rhs: &'b V) -> Self::Output {
         AdditiveShare {
             x: &self.x * rhs,
-            rx: &self.rx * &rhs.to_extended()
+            rx: &self.rx * rhs.to_extended(),
         }
     }
 }
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index c4daa655c..d9cec4182 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -116,7 +116,7 @@ impl<V: SharedValue> AddAssign<&Self> for AdditiveShare<V> {
 
 impl<V: SharedValue> AddAssign<Self> for AdditiveShare<V> {
     fn add_assign(&mut self, rhs: Self) {
-        AddAssign::add_assign(self, &rhs)
+        AddAssign::add_assign(self, &rhs);
     }
 }
 
@@ -177,7 +177,7 @@ impl<V: SharedValue> SubAssign<&Self> for AdditiveShare<V> {
 
 impl<V: SharedValue> SubAssign<Self> for AdditiveShare<V> {
     fn sub_assign(&mut self, rhs: Self) {
-        SubAssign::sub_assign(self, &rhs)
+        SubAssign::sub_assign(self, &rhs);
     }
 }
 
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index 1ea50ecca..d81f820aa 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -1,5 +1,7 @@
-use std::fmt::Debug;
-use std::ops::{Mul, Neg};
+use std::{
+    fmt::Debug,
+    ops::{Mul, Neg},
+};
 
 use super::SharedValue;
 use crate::ff::{GaloisField, LocalArithmeticOps, LocalAssignOps};
@@ -21,6 +23,5 @@ pub trait Linear<V: SharedValue>: SecretSharing<V>
     + Neg<Output=Self>
 {}
 
-
 /// Secret share of a secret in bits. It has additive and multiplicative properties.
 pub trait Bitwise<V: GaloisField>: SecretSharing<V> + Linear<V> {}

From 1c960fa3314580ec2b95c32c2499660182df2ce3 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 26 Sep 2023 11:05:02 -0700
Subject: [PATCH 011/105] Rename some traits for brevity

---
 src/ff/mod.rs                                     | 15 +++++++++------
 src/protocol/aggregation/mod.rs                   |  6 +++---
 .../attribution/apply_attribution_window.rs       |  8 ++++----
 src/protocol/attribution/credit_capping.rs        | 10 +++++-----
 src/protocol/attribution/mod.rs                   |  8 ++++----
 src/protocol/basics/if_else.rs                    |  4 ++--
 src/protocol/boolean/add_constant.rs              |  4 ++--
 src/protocol/boolean/bitwise_equal.rs             |  6 +++---
 src/protocol/boolean/comparison.rs                | 10 +++++-----
 src/protocol/boolean/random_bits_generator.rs     |  4 ++--
 src/protocol/boolean/solved_bits.rs               |  4 ++--
 src/protocol/ipa/mod.rs                           |  6 +++---
 src/protocol/sort/bit_permutation.rs              |  4 ++--
 src/query/runner/aggregate.rs                     |  4 ++--
 src/query/runner/ipa.rs                           |  6 +++---
 src/secret_sharing/decomposed.rs                  |  4 ++--
 src/secret_sharing/mod.rs                         | 10 +++++-----
 17 files changed, 58 insertions(+), 55 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 2622d6631..b1bf6c5da 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -40,9 +40,8 @@ impl<T, Rhs, Output> LocalArithmeticOps<Rhs, Output> for T where
 pub trait LocalAssignOps<Rhs = Self>: AddAssign<Rhs> + SubAssign<Rhs> {}
 impl<T, Rhs> LocalAssignOps<Rhs> for T where T: AddAssign<Rhs> + SubAssign<Rhs> {}
 
-/// TODO: add docs
-/// May or may not require communication, depending on the value. Multiplying field values is a
-/// local operation, while multiplying secret shares is not.
+/// Arithmetic operations that may or may not require communication.
+/// for example, multiplying field values is a local operation, while multiplying secret shares is not.
 pub trait ArithmeticOps<Rhs = Self, Output = Self>:
     LocalArithmeticOps<Rhs, Output>
     + LocalAssignOps<Rhs>
@@ -64,15 +63,19 @@ impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
 /// The trait for references which implement local arithmetic operations, taking the
 /// second operand either by value or by reference.
 ///
-/// This is automatically implemented for types which implement the operators.
-pub trait RefLocalArithmeticOps<'a, Base: 'a, R: 'a>:
+/// This is automatically implemented for types which implement the operators. The idea is borrowed
+/// from [`RefNum`] trait, but I couldn't really make it work with HRTB and secret shares. Primitive
+/// types worked just fine though, so it is possible that it is another compiler issue.
+///
+/// [`RefNum`]: https://docs.rs/num/0.4.1/num/traits/trait.RefNum.html
+pub trait RefOps<'a, Base: 'a, R: 'a>:
     LocalArithmeticOps<Base, Base>
     + LocalArithmeticOps<&'a Base, Base>
     + Mul<R, Output = Base>
     + Mul<&'a R, Output = Base>
 {
 }
-impl<'a, T, Base: 'a, R: 'a> RefLocalArithmeticOps<'a, Base, R> for T where
+impl<'a, T, Base: 'a, R: 'a> RefOps<'a, Base, R> for T where
     T: LocalArithmeticOps<Base, Base>
         + LocalArithmeticOps<&'a Base, Base>
         + 'a
diff --git a/src/protocol/aggregation/mod.rs b/src/protocol/aggregation/mod.rs
index 9fbf55453..58b722d8d 100644
--- a/src/protocol/aggregation/mod.rs
+++ b/src/protocol/aggregation/mod.rs
@@ -7,7 +7,7 @@ pub use input::SparseAggregateInputRow;
 use super::{context::Context, sort::bitwise_to_onehot, step::BitOpStep, RecordId};
 use crate::{
     error::Error,
-    ff::{Field, GaloisField, Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
+    ff::{Field, GaloisField, Gf2, PrimeField, RefOps, Serializable},
     protocol::{
         context::{UpgradableContext, UpgradedContext, Validator},
         modulus_conversion::convert_bits,
@@ -76,7 +76,7 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+    for<'r> &'r S: RefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2> + BasicProtocols<C::UpgradedContext<Gf2>, Gf2> + 'static,
     F: PrimeField + ExtendableField,
@@ -131,7 +131,7 @@ where
     I2: Stream<Item = Result<BitDecomposed<S>, Error>> + Send,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + Serializable + 'static,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     let equality_check_ctx = ctx.narrow(&Step::ComputeEqualityChecks);
 
diff --git a/src/protocol/attribution/apply_attribution_window.rs b/src/protocol/attribution/apply_attribution_window.rs
index 3c216c703..594fdc3fe 100644
--- a/src/protocol/attribution/apply_attribution_window.rs
+++ b/src/protocol/attribution/apply_attribution_window.rs
@@ -11,7 +11,7 @@ use super::{
 };
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, RefLocalArithmeticOps},
+    ff::{Field, PrimeField, RefOps},
     protocol::{
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
         context::{Context, UpgradedContext},
@@ -37,7 +37,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + 'static,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     if let Some(attribution_window_seconds) = attribution_window_seconds {
         let mut t_deltas = prefix_sum_time_deltas(&ctx, input, stop_bits).await?;
@@ -91,7 +91,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a T: RefLocalArithmeticOps<'a, T, F>,
+    for<'a> &'a T: RefOps<'a, T, F>,
 {
     let num_rows = input.len();
 
@@ -151,7 +151,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     let ctx = ctx.set_total_records(input.len());
     let random_bits_generator =
diff --git a/src/protocol/attribution/credit_capping.rs b/src/protocol/attribution/credit_capping.rs
index c278b76c2..4d2d362bd 100644
--- a/src/protocol/attribution/credit_capping.rs
+++ b/src/protocol/attribution/credit_capping.rs
@@ -9,7 +9,7 @@ use ipa_macros::Step;
 use super::{do_the_binary_tree_thing, input::CreditCappingInputRow, prefix_or_binary_tree_style};
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, RefLocalArithmeticOps},
+    ff::{Field, PrimeField, RefOps},
     protocol::{
         basics::{if_else, SecureMul},
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
@@ -35,7 +35,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     if cap == 1 {
         return Ok(credit_capping_max_one(ctx, input)
@@ -242,7 +242,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     let share_of_cap = S::share_known_value(&ctx, F::truncate_from(cap));
     let cap_ref = &share_of_cap;
@@ -297,7 +297,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(prefix_summed_credits.len());
@@ -360,7 +360,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a T: RefLocalArithmeticOps<'a, T, F>,
+    for<'a> &'a T: RefOps<'a, T, F>,
 {
     let num_rows = input.len();
     let cap_share = T::share_known_value(&ctx, F::try_from(cap.into()).unwrap());
diff --git a/src/protocol/attribution/mod.rs b/src/protocol/attribution/mod.rs
index 50ad92e63..207eb08f1 100644
--- a/src/protocol/attribution/mod.rs
+++ b/src/protocol/attribution/mod.rs
@@ -19,7 +19,7 @@ use self::{
 };
 use crate::{
     error::Error,
-    ff::{Field, Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
+    ff::{Field, Gf2, PrimeField, RefOps, Serializable},
     helpers::query::IpaQueryConfig,
     protocol::{
         basics::SecureMul,
@@ -62,13 +62,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB> + Context,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for<'a> &'a SB: RefLocalArithmeticOps<'a, SB, Gf2>,
+    for<'a> &'a SB: RefOps<'a, SB, Gf2>,
     F: PrimeField + ExtendableField,
     ShuffledPermutationWrapper<S, C::UpgradedContext<F>>: DowngradeMalicious<Target = Vec<u32>>,
 {
@@ -405,7 +405,7 @@ async fn compute_helper_bits_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>,
+    for<'a> &'a S: RefOps<'a, S, Gf2>,
 {
     let narrowed_ctx = ctx
         .narrow(&Step::ComputeHelperBits)
diff --git a/src/protocol/basics/if_else.rs b/src/protocol/basics/if_else.rs
index 85e7e0685..ebbc70e9a 100644
--- a/src/protocol/basics/if_else.rs
+++ b/src/protocol/basics/if_else.rs
@@ -1,6 +1,6 @@
 use crate::{
     error::Error,
-    ff::{Field, RefLocalArithmeticOps},
+    ff::{Field, RefOps},
     protocol::{basics::SecureMul, context::Context, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
@@ -19,7 +19,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + SecureMul<C>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     // If `condition` is a share of 1 (true), then
     //   = false_value + 1 * (true_value - false_value)
diff --git a/src/protocol/boolean/add_constant.rs b/src/protocol/boolean/add_constant.rs
index 004aebd12..9ef17954e 100644
--- a/src/protocol/boolean/add_constant.rs
+++ b/src/protocol/boolean/add_constant.rs
@@ -1,6 +1,6 @@
 use crate::{
     error::Error,
-    ff::{Field, RefLocalArithmeticOps},
+    ff::{Field, RefOps},
     protocol::{context::Context, step::BitOpStep, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
@@ -52,7 +52,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     let mut output = Vec::with_capacity(a.len() + 1);
 
diff --git a/src/protocol/boolean/bitwise_equal.rs b/src/protocol/boolean/bitwise_equal.rs
index 2d29d858d..931a4caae 100644
--- a/src/protocol/boolean/bitwise_equal.rs
+++ b/src/protocol/boolean/bitwise_equal.rs
@@ -2,7 +2,7 @@ use std::iter::zip;
 
 use crate::{
     error::Error,
-    ff::{Field, Gf2, RefLocalArithmeticOps},
+    ff::{Field, Gf2, RefOps},
     protocol::{boolean::all_zeroes, context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
@@ -24,7 +24,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -57,7 +57,7 @@ pub async fn bitwise_equal_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, Gf2>,
+    for<'a> &'a S: RefOps<'a, S, Gf2>,
 {
     debug_assert!(a.len() == b.len());
     let c = zip(a.iter(), b.iter())
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 4f40b5096..5d72a02c3 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -3,7 +3,7 @@ use ipa_macros::Step;
 use super::or::or;
 use crate::{
     error::Error,
-    ff::{PrimeField, RefLocalArithmeticOps},
+    ff::{PrimeField, RefOps},
     protocol::{
         boolean::random_bits_generator::RandomBitsGenerator,
         context::{Context, UpgradedContext},
@@ -73,7 +73,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     use GreaterThanConstantStep as Step;
 
@@ -175,7 +175,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -208,7 +208,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -239,7 +239,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     let one = S::share_known_value(ctx, F::ONE);
 
diff --git a/src/protocol/boolean/random_bits_generator.rs b/src/protocol/boolean/random_bits_generator.rs
index 481330cb1..6664bf62f 100644
--- a/src/protocol/boolean/random_bits_generator.rs
+++ b/src/protocol/boolean/random_bits_generator.rs
@@ -7,7 +7,7 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{PrimeField, RefLocalArithmeticOps},
+    ff::{PrimeField, RefOps},
     helpers::TotalRecords,
     protocol::{
         boolean::solved_bits::{solved_bits, RandomBitsShare},
@@ -44,7 +44,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     #[must_use]
     pub fn new(ctx: C) -> Self {
diff --git a/src/protocol/boolean/solved_bits.rs b/src/protocol/boolean/solved_bits.rs
index 4359d1134..c289407e2 100644
--- a/src/protocol/boolean/solved_bits.rs
+++ b/src/protocol/boolean/solved_bits.rs
@@ -5,7 +5,7 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, RefLocalArithmeticOps},
+    ff::{Field, PrimeField, RefOps},
     protocol::{
         boolean::{
             bitwise_less_than_prime::BitwiseLessThanPrime, generate_random_bits::one_random_bit,
@@ -94,7 +94,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     //
     // step 1 & 2
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index 735246668..610d0cfe9 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -11,7 +11,7 @@ use typenum::Unsigned;
 
 use crate::{
     error::Error,
-    ff::{Field, GaloisField, Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
+    ff::{Field, GaloisField, Gf2, PrimeField, RefOps, Serializable},
     helpers::{query::IpaQueryConfig, Role},
     protocol::{
         attribution::secure_attribution,
@@ -315,13 +315,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+    for<'r> &'r S: RefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for<'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
+    for<'r> &'r SB: RefOps<'r, SB, Gf2>,
     F: PrimeField + ExtendableField,
     MK: GaloisField,
     BK: GaloisField,
diff --git a/src/protocol/sort/bit_permutation.rs b/src/protocol/sort/bit_permutation.rs
index de9b28bac..7f8fcbb5a 100644
--- a/src/protocol/sort/bit_permutation.rs
+++ b/src/protocol/sort/bit_permutation.rs
@@ -4,7 +4,7 @@ use embed_doc_image::embed_doc_image;
 
 use crate::{
     error::Error,
-    ff::{Field, RefLocalArithmeticOps},
+    ff::{Field, RefOps},
     protocol::{context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
@@ -41,7 +41,7 @@ pub async fn bit_permutation<
     input: &[S],
 ) -> Result<Vec<S>, Error>
 where
-    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+    for<'r> &'r S: RefOps<'r, S, F>,
 {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(2 * input.len());
diff --git a/src/query/runner/aggregate.rs b/src/query/runner/aggregate.rs
index 9ab98c15a..b0b64c4ad 100644
--- a/src/query/runner/aggregate.rs
+++ b/src/query/runner/aggregate.rs
@@ -5,7 +5,7 @@ use futures_util::TryStreamExt;
 use super::ipa::assert_stream_send;
 use crate::{
     error::Error,
-    ff::{Gf2, Gf8Bit, PrimeField, RefLocalArithmeticOps, Serializable},
+    ff::{Gf2, Gf8Bit, PrimeField, RefOps, Serializable},
     helpers::{
         query::{QuerySize, SparseAggregateQueryConfig},
         BodyStream, RecordsStream,
@@ -53,7 +53,7 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+    for<'r> &'r S: RefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
diff --git a/src/query/runner/ipa.rs b/src/query/runner/ipa.rs
index 4f2ac3921..7c847ca21 100644
--- a/src/query/runner/ipa.rs
+++ b/src/query/runner/ipa.rs
@@ -7,7 +7,7 @@ use futures::{
 
 use crate::{
     error::Error,
-    ff::{Gf2, PrimeField, RefLocalArithmeticOps, Serializable},
+    ff::{Gf2, PrimeField, RefOps, Serializable},
     helpers::{
         query::{IpaQueryConfig, QuerySize},
         BodyStream, LengthDelimitedStream, RecordsStream,
@@ -55,13 +55,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefLocalArithmeticOps<'r, S, F>,
+    for<'r> &'r S: RefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for<'r> &'r SB: RefLocalArithmeticOps<'r, SB, Gf2>,
+    for<'r> &'r SB: RefOps<'r, SB, Gf2>,
     F: PrimeField,
     Replicated<F>: Serializable + ShareKnownValue<C, F>,
     IPAInputRow<F, MatchKey, BreakdownKey>: Serializable,
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 5cd64e6e9..3b7305217 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -2,7 +2,7 @@ use std::{fmt::Debug, ops::Deref};
 
 use crate::{
     error::Error,
-    ff::{PrimeField, RefLocalArithmeticOps},
+    ff::{PrimeField, RefOps},
     secret_sharing::Linear as LinearSecretSharing,
 };
 
@@ -60,7 +60,7 @@ impl<S> BitDecomposed<S> {
     pub fn to_additive_sharing_in_large_field<F>(&self) -> S
     where
         S: LinearSecretSharing<F>,
-        for<'a> &'a S: RefLocalArithmeticOps<'a, S, F>,
+        for<'a> &'a S: RefOps<'a, S, F>,
         F: PrimeField,
     {
         self.iter().enumerate().fold(S::ZERO, |acc, (i, b)| {
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index a1dd93061..0bc43278a 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -59,7 +59,7 @@ where
 #[cfg(all(test, unit_test))]
 mod tests {
     use crate::{
-        ff::{Fp31, RefLocalArithmeticOps},
+        ff::{Fp31, RefOps},
         secret_sharing::{
             replicated::{malicious, semi_honest},
             Linear, SharedValue,
@@ -68,7 +68,7 @@ mod tests {
 
     fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>()
     where
-        for<'a> &'a L: RefLocalArithmeticOps<'a, L, V>,
+        for<'a> &'a L: RefOps<'a, L, V>,
     {
         let a = L::ZERO;
         let b = L::ZERO;
@@ -81,7 +81,7 @@ mod tests {
 
     fn trait_bounds<L: Linear<V> + PartialEq, V: SharedValue>()
     where
-        for<'a> &'a L: RefLocalArithmeticOps<'a, L, V>,
+        for<'a> &'a L: RefOps<'a, L, V>,
     {
         fn sum_owned<S: Linear<V>, V: SharedValue>(a: S, b: S) -> S {
             a + b
@@ -91,7 +91,7 @@ mod tests {
         where
             S: Linear<V>,
             V: SharedValue,
-            for<'a> &'a S: RefLocalArithmeticOps<'a, S, V>,
+            for<'a> &'a S: RefOps<'a, S, V>,
         {
             a + b
         }
@@ -104,7 +104,7 @@ mod tests {
         where
             S: Linear<V>,
             V: SharedValue,
-            for<'a> &'a S: RefLocalArithmeticOps<'a, S, V>,
+            for<'a> &'a S: RefOps<'a, S, V>,
         {
             a + b
         }

From 990dd689a19080ea0a34cc0088bb753aaa95b22a Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 26 Sep 2023 11:28:44 -0700
Subject: [PATCH 012/105] Fix benches

---
 src/protocol/aggregation/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/protocol/aggregation/mod.rs b/src/protocol/aggregation/mod.rs
index 58b722d8d..a50715a8b 100644
--- a/src/protocol/aggregation/mod.rs
+++ b/src/protocol/aggregation/mod.rs
@@ -174,6 +174,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + Serializable + 'static,
+    for<'a> &'a S: RefOps<'a, S, F>,
 {
     let check_times_value_ctx = ctx.narrow(&Step::CheckTimesValue);
 

From efe1261cc3c71e57cd3136f9e662cb9cc7c15693 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 26 Sep 2023 11:33:05 -0700
Subject: [PATCH 013/105] Add a reference to the rust issue that causes HRTB
 bound to appear everywhere

---
 src/ff/mod.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index b1bf6c5da..cd64d7d9e 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -63,11 +63,15 @@ impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
 /// The trait for references which implement local arithmetic operations, taking the
 /// second operand either by value or by reference.
 ///
+/// The need for this trait is dictated by [`rust-issue`] that causes us not being able to constrain
+/// references to `Self`. Once this issue is fixed, we can simply get rid of it.
+///
 /// This is automatically implemented for types which implement the operators. The idea is borrowed
 /// from [`RefNum`] trait, but I couldn't really make it work with HRTB and secret shares. Primitive
 /// types worked just fine though, so it is possible that it is another compiler issue.
 ///
 /// [`RefNum`]: https://docs.rs/num/0.4.1/num/traits/trait.RefNum.html
+/// [`rust-issue`]: https://github.com/rust-lang/rust/issues/20671
 pub trait RefOps<'a, Base: 'a, R: 'a>:
     LocalArithmeticOps<Base, Base>
     + LocalArithmeticOps<&'a Base, Base>

From 664b86e7554225c4cc6ab023e68a66deaa69dba2 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 26 Sep 2023 13:47:26 -0700
Subject: [PATCH 014/105] Clean up the code

---
 src/protocol/basics/reveal.rs                         |  2 +-
 src/secret_sharing/mod.rs                             |  1 -
 .../replicated/semi_honest/additive_share.rs          |  2 --
 src/secret_sharing/scheme.rs                          | 11 ++++++-----
 4 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/protocol/basics/reveal.rs b/src/protocol/basics/reveal.rs
index d89fb7ec6..28e54a904 100644
--- a/src/protocol/basics/reveal.rs
+++ b/src/protocol/basics/reveal.rs
@@ -255,7 +255,7 @@ mod tests {
 
         let m_shares = join3v(
             zip(m_ctx.iter(), input.share_with(&mut rng))
-                .map(|(m_ctx, share)| async move { m_ctx.upgrade(share).await }),
+                .map(|(m_ctx, share)| async { m_ctx.upgrade(share).await }),
         )
         .await;
         let result = try_join3(
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 0bc43278a..1ada1b8dd 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -27,7 +27,6 @@ pub trait Block: Sized + Copy + Debug {
 }
 
 pub trait SharedValue:
-// TODO: add reference operations
     Clone + Copy + PartialEq + Debug + Send + Sync + Sized + ArithmeticOps + Serializable + 'static
 {
     type Storage: Block;
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index d9cec4182..7982d81fb 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -23,8 +23,6 @@ impl<V: SharedValue> SecretSharing<V> for AdditiveShare<V> {
 
 impl<V: SharedValue> LinearSecretSharing<V> for AdditiveShare<V> {}
 
-// impl <'a, V: SharedValue> RefLocalArithmeticOps<'a, Self> for AdditiveShare<V> {}
-
 impl<V: SharedValue + Debug> Debug for AdditiveShare<V> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "({:?}, {:?})", self.0, self.1)
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index d81f820aa..8d1502fa8 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -12,16 +12,17 @@ pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
 }
 
 /// Secret share of a secret that has additive and multiplicative properties.
-pub trait Linear<V: SharedValue>: SecretSharing<V>
+pub trait Linear<V: SharedValue>:
+    SecretSharing<V>
     + LocalArithmeticOps
     + LocalAssignOps
     + for<'r> LocalArithmeticOps<&'r Self>
     + for<'r> LocalAssignOps<&'r Self>
-    // TODO: add reference
-    + Mul<V, Output=Self>
+    + Mul<V, Output = Self>
     + for<'r> Mul<&'r V, Output = Self>
-    + Neg<Output=Self>
-{}
+    + Neg<Output = Self>
+{
+}
 
 /// Secret share of a secret in bits. It has additive and multiplicative properties.
 pub trait Bitwise<V: GaloisField>: SecretSharing<V> + Linear<V> {}

From c38f16b040759243d80ecbb8e4fbefd045a60f34 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Wed, 27 Sep 2023 10:25:28 -0700
Subject: [PATCH 015/105] Address feedback

---
 src/secret_sharing/replicated/semi_honest/additive_share.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index 7982d81fb..cc48cf78b 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -89,7 +89,7 @@ impl<V: SharedValue> Add<Self> for AdditiveShare<V> {
     }
 }
 
-impl<'a, V: SharedValue> Add<AdditiveShare<V>> for &'a AdditiveShare<V> {
+impl<V: SharedValue> Add<AdditiveShare<V>> for &AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
     fn add(self, rhs: AdditiveShare<V>) -> Self::Output {
@@ -97,10 +97,10 @@ impl<'a, V: SharedValue> Add<AdditiveShare<V>> for &'a AdditiveShare<V> {
     }
 }
 
-impl<'a, V: SharedValue> Add<&'a AdditiveShare<V>> for AdditiveShare<V> {
+impl<V: SharedValue> Add<&AdditiveShare<V>> for AdditiveShare<V> {
     type Output = Self;
 
-    fn add(self, rhs: &'a Self) -> Self::Output {
+    fn add(self, rhs: &Self) -> Self::Output {
         Add::add(&self, rhs)
     }
 }

From 5ac3d0826f3919e6a31d5535a533f37fa1a99a75 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Thu, 28 Sep 2023 21:55:06 +0800
Subject: [PATCH 016/105] WIP aggregation logic

---
 src/protocol/attribution/aggregate_credit.rs |   2 +-
 src/protocol/prf_sharding/mod.rs             | 125 +++++++++++++++++--
 2 files changed, 119 insertions(+), 8 deletions(-)

diff --git a/src/protocol/attribution/aggregate_credit.rs b/src/protocol/attribution/aggregate_credit.rs
index 6d607b1c1..a038875e0 100644
--- a/src/protocol/attribution/aggregate_credit.rs
+++ b/src/protocol/attribution/aggregate_credit.rs
@@ -68,7 +68,7 @@ where
     }
 }
 
-async fn simple_aggregate_credit<F, C, IC, IB, S>(
+pub async fn simple_aggregate_credit<F, C, IC, IB, S>(
     ctx: C,
     breakdown_keys: IB,
     capped_credits: IC,
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index ce2da899d..0fa66e41f 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1,12 +1,20 @@
 use std::iter::{repeat, zip};
 
-use futures_util::future::try_join;
+use futures_util::{future::try_join, StreamExt};
 use ipa_macros::Step;
 
-use super::{basics::if_else, boolean::saturating_sum::SaturatingSum, step::BitOpStep};
+use super::{
+    basics::{if_else, mul::malicious::multiply},
+    boolean::saturating_sum::SaturatingSum,
+    modulus_conversion::convert_bits,
+    step::BitOpStep,
+    BasicProtocols,
+};
+use futures::stream::unfold;
+
 use crate::{
     error::Error,
-    ff::{Field, GaloisField, Gf2},
+    ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
     protocol::{
         basics::{SecureMul, ShareKnownValue},
         boolean::or::or,
@@ -14,12 +22,15 @@ use crate::{
         RecordId,
     },
     secret_sharing::{
-        replicated::{semi_honest::AdditiveShare as Replicated, ReplicatedSecretSharing},
-        BitDecomposed, SharedValue,
+        replicated::{
+            malicious::ExtendableField, semi_honest::AdditiveShare as Replicated,
+            ReplicatedSecretSharing,
+        },
+        BitDecomposed, Linear as LinearSecretSharing, SharedValue,
     },
-    seq_join::seq_try_join_all,
+    seq_join::{seq_join, seq_try_join_all},
 };
-
+use futures::stream::iter as stream_iter;
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {
     prf_of_match_key: u64,
     is_trigger_bit: Replicated<Gf2>,
@@ -170,6 +181,11 @@ pub struct CappedAttributionOutputs {
     pub capped_attributed_trigger_value: BitDecomposed<Replicated<Gf2>>,
 }
 
+pub struct PrimeFieldAggregationInputs<F: Field> {
+    pub attributed_breakdown_key_bits: BitDecomposed<Replicated<F>>,
+    pub capped_attributed_trigger_value: Replicated<F>,
+}
+
 #[derive(Step)]
 pub enum UserNthRowStep {
     #[dynamic]
@@ -194,6 +210,11 @@ pub(crate) enum Step {
     ComputeDifferenceToCap,
     ComputedCappedAttributedTriggerValueNotSaturatedCase,
     ComputedCappedAttributedTriggerValueJustSaturatedCase,
+    ComputedAttributedBreakdownKey,
+    ComputedAttributedValue,
+    ComputeEqualityChecks,
+    CheckTimesCredit,
+    AttributionAndCapping,
 }
 
 fn compute_histogram_of_users_with_row_count<S>(rows_chunked_by_user: &[Vec<S>]) -> Vec<usize> {
@@ -252,6 +273,96 @@ where
     rows_chunked_by_user
 }
 
+pub async fn attribution_and_capping_and_aggregation<C, BK, TV, F, S, SB>(
+    sh_ctx: C,
+    input_rows: Vec<PrfShardedIpaInputRow<BK, TV>>,
+    num_saturating_sum_bits: usize,
+) -> Result<Vec<Replicated<F>>, Error>
+where
+    C: UpgradableContext,
+    C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + BasicProtocols<C, F>,
+    C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+    F: PrimeField + ExtendableField,
+    TV: GaloisField,
+    BK: GaloisField,
+    //for<'u> UpgradeContext<'u, C::UpgradedContext<F>, F, RecordId>: UpgradeToMalicious<'u, BitConversionTriple<Replicated<F>>, BitConversionTriple<S>>
+{
+    // Call attribution_and_capping
+    let user_level_attributions: Vec<CappedAttributionOutputs> =
+        attribution_and_capping(sh_ctx.clone(), input_rows, num_saturating_sum_bits).await?;
+
+    let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
+    let prime_field_m_ctx = prime_field_validator.context();
+
+    // call aggregation protocol which checks onehot and multiplies value to each bucket
+
+    do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
+}
+
+async fn do_aggregation<C, BK, TV, F, S>(
+    ctx: C,
+    user_level_attributions: Vec<CappedAttributionOutputs>,
+) -> Result<Vec<Replicated<F>>, Error>
+where
+    C: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + BasicProtocols<C, F>,
+    BK: GaloisField,
+    TV: GaloisField,
+    F: PrimeField + ExtendableField,
+{
+    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
+        .into_iter()
+        .map(|row| {
+            (
+                row.attributed_breakdown_key_bits,
+                row.capped_attributed_trigger_value,
+            )
+        })
+        .unzip();
+
+    // convert bk
+    // TODO fix set_total_records
+    let converted_bks = convert_bits(
+        ctx.narrow(&Step::ComputedAttributedBreakdownKey),
+        // .set_total_records(BK::BITS.into()),
+        stream_iter(bk_vec),
+        0..BK::BITS,
+    );
+    // convert attributed value
+    // TODO fix set_total_records
+
+    let converted_values = convert_bits(
+        ctx.narrow(&Step::ComputedAttributedValue),
+        // .set_total_records(TV::BITS.into()),
+        stream_iter(tv_vec),
+        0..TV::BITS,
+    );
+    let large_field_value =
+        converted_values.map(|val| val.unwrap().to_additive_sharing_in_large_field());
+
+    // let stream = unfold(
+    //     (ctx, converted_bks, large_field_value, RecordId(0)),
+    //     |(ctx, mut converted_bks, mut large_field_value, record_id)| async move {
+    //         let Some(bk_bits) = converted_bks.next().await else {
+    //             return None;
+    //         };
+    //         let Some(val) = large_field_value.next().await else {
+    //             return None;
+    //         };
+    //         let output = bk_bits.unwrap()[0].multiply(val, ctx, record_id);
+
+    //         Some((
+    //             output,
+    //             (ctx, converted_bks, large_field_value, record_id + 1),
+    //         ))
+    //     },
+    // );
+    // seq_join(ctx.active_work(), stream).await;
+    // Some((converted, (ctx, locally_converted, record_id + 1)))
+    Ok(vec![])
+    // tree_aggregate_credit(ctx, converted_bks, large_field_value, 1 << BK::BITS).await
+}
 /// Sub-protocol of the PRF-sharded IPA Protocol
 ///
 /// After the computation of the per-user PRF, addition of dummy records and shuffling,

From b43905cacba743b5f81c99584c9f1738d0c18744 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 28 Sep 2023 09:34:08 -0700
Subject: [PATCH 017/105] Remove one more clone

thanks to mt@'s eagle eye vision.
---
 src/protocol/basics/if_else.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/protocol/basics/if_else.rs b/src/protocol/basics/if_else.rs
index ebbc70e9a..315e4ab85 100644
--- a/src/protocol/basics/if_else.rs
+++ b/src/protocol/basics/if_else.rs
@@ -29,7 +29,7 @@ where
     // If `condition` is a share of 0 (false), then
     //   = false_value + 0 * (true_value - false_value)
     //   = false_value
-    Ok(false_value.clone()
+    Ok(false_value
         + &condition
             .multiply(&(true_value - false_value), ctx, record_id)
             .await?)

From d0af8f85f2af7ae87738761f94491d45d6de8e44 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 28 Sep 2023 09:49:58 -0700
Subject: [PATCH 018/105] Move RefOps trait to secret sharing module

It is too specific to be in the finite fields, basically nothing except `Linear` can conform to it
---
 src/ff/mod.rs                                 | 27 -----------------
 src/protocol/aggregation/mod.rs               |  3 +-
 .../attribution/apply_attribution_window.rs   |  3 +-
 src/protocol/attribution/credit_capping.rs    |  3 +-
 src/protocol/attribution/mod.rs               |  3 +-
 src/protocol/basics/if_else.rs                |  3 +-
 src/protocol/boolean/add_constant.rs          |  3 +-
 src/protocol/boolean/bitwise_equal.rs         |  3 +-
 src/protocol/boolean/comparison.rs            |  3 +-
 src/protocol/boolean/random_bits_generator.rs |  3 +-
 src/protocol/boolean/solved_bits.rs           |  3 +-
 src/protocol/ipa/mod.rs                       |  3 +-
 src/protocol/sort/bit_permutation.rs          |  3 +-
 src/query/runner/aggregate.rs                 |  3 +-
 src/query/runner/ipa.rs                       |  3 +-
 src/secret_sharing/decomposed.rs              |  3 +-
 src/secret_sharing/mod.rs                     |  5 ++--
 src/secret_sharing/scheme.rs                  | 29 +++++++++++++++++++
 18 files changed, 62 insertions(+), 44 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index cd64d7d9e..49b11392e 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -60,33 +60,6 @@ impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
 {
 }
 
-/// The trait for references which implement local arithmetic operations, taking the
-/// second operand either by value or by reference.
-///
-/// The need for this trait is dictated by [`rust-issue`] that causes us not being able to constrain
-/// references to `Self`. Once this issue is fixed, we can simply get rid of it.
-///
-/// This is automatically implemented for types which implement the operators. The idea is borrowed
-/// from [`RefNum`] trait, but I couldn't really make it work with HRTB and secret shares. Primitive
-/// types worked just fine though, so it is possible that it is another compiler issue.
-///
-/// [`RefNum`]: https://docs.rs/num/0.4.1/num/traits/trait.RefNum.html
-/// [`rust-issue`]: https://github.com/rust-lang/rust/issues/20671
-pub trait RefOps<'a, Base: 'a, R: 'a>:
-    LocalArithmeticOps<Base, Base>
-    + LocalArithmeticOps<&'a Base, Base>
-    + Mul<R, Output = Base>
-    + Mul<&'a R, Output = Base>
-{
-}
-impl<'a, T, Base: 'a, R: 'a> RefOps<'a, Base, R> for T where
-    T: LocalArithmeticOps<Base, Base>
-        + LocalArithmeticOps<&'a Base, Base>
-        + 'a
-        + Mul<R, Output = Base>
-        + Mul<&'a R, Output = Base>
-{
-}
 
 /// Trait for items that have fixed-byte length representation.
 pub trait Serializable: Sized {
diff --git a/src/protocol/aggregation/mod.rs b/src/protocol/aggregation/mod.rs
index a50715a8b..435234690 100644
--- a/src/protocol/aggregation/mod.rs
+++ b/src/protocol/aggregation/mod.rs
@@ -7,7 +7,7 @@ pub use input::SparseAggregateInputRow;
 use super::{context::Context, sort::bitwise_to_onehot, step::BitOpStep, RecordId};
 use crate::{
     error::Error,
-    ff::{Field, GaloisField, Gf2, PrimeField, RefOps, Serializable},
+    ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
     protocol::{
         context::{UpgradableContext, UpgradedContext, Validator},
         modulus_conversion::convert_bits,
@@ -23,6 +23,7 @@ use crate::{
     },
     seq_join::seq_join,
 };
+use crate::secret_sharing::RefOps;
 
 // TODO: Use `#[derive(Step)]` once the protocol is implemented and the bench test is enabled.
 //       Once that is done, run `collect_steps.py` to generate `steps.txt` that includes these steps.
diff --git a/src/protocol/attribution/apply_attribution_window.rs b/src/protocol/attribution/apply_attribution_window.rs
index 594fdc3fe..0314f4d86 100644
--- a/src/protocol/attribution/apply_attribution_window.rs
+++ b/src/protocol/attribution/apply_attribution_window.rs
@@ -11,7 +11,7 @@ use super::{
 };
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, RefOps},
+    ff::{Field, PrimeField, },
     protocol::{
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
         context::{Context, UpgradedContext},
@@ -19,6 +19,7 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 /// This protocol applies the specified attribution window to trigger events. All trigger values of
 /// events that are outside the window will be replaced with 0, hence will not be attributed to
diff --git a/src/protocol/attribution/credit_capping.rs b/src/protocol/attribution/credit_capping.rs
index 4d2d362bd..bc37d76ad 100644
--- a/src/protocol/attribution/credit_capping.rs
+++ b/src/protocol/attribution/credit_capping.rs
@@ -9,7 +9,7 @@ use ipa_macros::Step;
 use super::{do_the_binary_tree_thing, input::CreditCappingInputRow, prefix_or_binary_tree_style};
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, RefOps},
+    ff::{Field, PrimeField, },
     protocol::{
         basics::{if_else, SecureMul},
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
@@ -19,6 +19,7 @@ use crate::{
     secret_sharing::Linear as LinearSecretSharing,
     seq_join::seq_join,
 };
+use crate::secret_sharing::RefOps;
 
 /// User-level credit capping protocol.
 ///
diff --git a/src/protocol/attribution/mod.rs b/src/protocol/attribution/mod.rs
index 207eb08f1..3be107298 100644
--- a/src/protocol/attribution/mod.rs
+++ b/src/protocol/attribution/mod.rs
@@ -19,7 +19,7 @@ use self::{
 };
 use crate::{
     error::Error,
-    ff::{Field, Gf2, PrimeField, RefOps, Serializable},
+    ff::{Field, Gf2, PrimeField, Serializable},
     helpers::query::IpaQueryConfig,
     protocol::{
         basics::SecureMul,
@@ -39,6 +39,7 @@ use crate::{
     },
     seq_join::assert_send,
 };
+use crate::secret_sharing::RefOps;
 
 /// Performs a set of attribution protocols on the sorted IPA input.
 ///
diff --git a/src/protocol/basics/if_else.rs b/src/protocol/basics/if_else.rs
index 315e4ab85..265ee179f 100644
--- a/src/protocol/basics/if_else.rs
+++ b/src/protocol/basics/if_else.rs
@@ -1,9 +1,10 @@
 use crate::{
     error::Error,
-    ff::{Field, RefOps},
+    ff::{Field, },
     protocol::{basics::SecureMul, context::Context, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 /// Returns `true_value` if `condition` is a share of 1, else `false_value`.
 /// # Errors
diff --git a/src/protocol/boolean/add_constant.rs b/src/protocol/boolean/add_constant.rs
index 9ef17954e..fa5c35185 100644
--- a/src/protocol/boolean/add_constant.rs
+++ b/src/protocol/boolean/add_constant.rs
@@ -1,9 +1,10 @@
 use crate::{
     error::Error,
-    ff::{Field, RefOps},
+    ff::{Field, },
     protocol::{context::Context, step::BitOpStep, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 /// This is an implementation of a Bitwise Sum of a bitwise-shared number with a constant.
 ///
diff --git a/src/protocol/boolean/bitwise_equal.rs b/src/protocol/boolean/bitwise_equal.rs
index 931a4caae..e305ef748 100644
--- a/src/protocol/boolean/bitwise_equal.rs
+++ b/src/protocol/boolean/bitwise_equal.rs
@@ -2,10 +2,11 @@ use std::iter::zip;
 
 use crate::{
     error::Error,
-    ff::{Field, Gf2, RefOps},
+    ff::{Field, Gf2, },
     protocol::{boolean::all_zeroes, context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 /// Compares `[a]` and `c`, and returns 1 iff `a == c`
 ///
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 5d72a02c3..273e6b87c 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -3,7 +3,7 @@ use ipa_macros::Step;
 use super::or::or;
 use crate::{
     error::Error,
-    ff::{PrimeField, RefOps},
+    ff::{PrimeField, },
     protocol::{
         boolean::random_bits_generator::RandomBitsGenerator,
         context::{Context, UpgradedContext},
@@ -12,6 +12,7 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 // Compare an arithmetic-shared value `a` to a known value `c`.
 //
diff --git a/src/protocol/boolean/random_bits_generator.rs b/src/protocol/boolean/random_bits_generator.rs
index 6664bf62f..4ed99bf8e 100644
--- a/src/protocol/boolean/random_bits_generator.rs
+++ b/src/protocol/boolean/random_bits_generator.rs
@@ -7,7 +7,7 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{PrimeField, RefOps},
+    ff::{PrimeField, },
     helpers::TotalRecords,
     protocol::{
         boolean::solved_bits::{solved_bits, RandomBitsShare},
@@ -16,6 +16,7 @@ use crate::{
     },
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 /// A struct that generates random sharings of bits from the
 /// `SolvedBits` protocol. Any protocol who wish to use a random-bits can draw
diff --git a/src/protocol/boolean/solved_bits.rs b/src/protocol/boolean/solved_bits.rs
index c289407e2..a113b8323 100644
--- a/src/protocol/boolean/solved_bits.rs
+++ b/src/protocol/boolean/solved_bits.rs
@@ -5,7 +5,7 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, RefOps},
+    ff::{Field, PrimeField, },
     protocol::{
         boolean::{
             bitwise_less_than_prime::BitwiseLessThanPrime, generate_random_bits::one_random_bit,
@@ -21,6 +21,7 @@ use crate::{
         BitDecomposed, Linear as LinearSecretSharing, SecretSharing,
     },
 };
+use crate::secret_sharing::RefOps;
 
 #[derive(Debug)]
 pub struct RandomBitsShare<F, S>
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index 610d0cfe9..4cd392f91 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -11,7 +11,7 @@ use typenum::Unsigned;
 
 use crate::{
     error::Error,
-    ff::{Field, GaloisField, Gf2, PrimeField, RefOps, Serializable},
+    ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
     helpers::{query::IpaQueryConfig, Role},
     protocol::{
         attribution::secure_attribution,
@@ -38,6 +38,7 @@ use crate::{
         BitDecomposed, Linear as LinearSecretSharing,
     },
 };
+use crate::secret_sharing::RefOps;
 
 #[derive(Step)]
 pub(crate) enum Step {
diff --git a/src/protocol/sort/bit_permutation.rs b/src/protocol/sort/bit_permutation.rs
index 7f8fcbb5a..95a860ce7 100644
--- a/src/protocol/sort/bit_permutation.rs
+++ b/src/protocol/sort/bit_permutation.rs
@@ -4,10 +4,11 @@ use embed_doc_image::embed_doc_image;
 
 use crate::{
     error::Error,
-    ff::{Field, RefOps},
+    ff::{Field, },
     protocol::{context::Context, BasicProtocols, RecordId},
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 #[embed_doc_image("bit_permutation", "images/sort/bit_permutations.png")]
 /// This is an implementation of `GenBitPerm` (Algorithm 3) described in:
diff --git a/src/query/runner/aggregate.rs b/src/query/runner/aggregate.rs
index b0b64c4ad..03aacf218 100644
--- a/src/query/runner/aggregate.rs
+++ b/src/query/runner/aggregate.rs
@@ -5,7 +5,7 @@ use futures_util::TryStreamExt;
 use super::ipa::assert_stream_send;
 use crate::{
     error::Error,
-    ff::{Gf2, Gf8Bit, PrimeField, RefOps, Serializable},
+    ff::{Gf2, Gf8Bit, PrimeField, Serializable},
     helpers::{
         query::{QuerySize, SparseAggregateQueryConfig},
         BodyStream, RecordsStream,
@@ -23,6 +23,7 @@ use crate::{
     },
     sync::Arc,
 };
+use crate::secret_sharing::RefOps;
 
 pub struct SparseAggregateQuery<F, C, S> {
     config: SparseAggregateQueryConfig,
diff --git a/src/query/runner/ipa.rs b/src/query/runner/ipa.rs
index 7c847ca21..482e5637b 100644
--- a/src/query/runner/ipa.rs
+++ b/src/query/runner/ipa.rs
@@ -7,7 +7,7 @@ use futures::{
 
 use crate::{
     error::Error,
-    ff::{Gf2, PrimeField, RefOps, Serializable},
+    ff::{Gf2, PrimeField, Serializable},
     helpers::{
         query::{IpaQueryConfig, QuerySize},
         BodyStream, LengthDelimitedStream, RecordsStream,
@@ -28,6 +28,7 @@ use crate::{
     },
     sync::Arc,
 };
+use crate::secret_sharing::RefOps;
 
 pub struct IpaQuery<F, C, S> {
     config: IpaQueryConfig,
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 3b7305217..e5ccc630b 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -2,9 +2,10 @@ use std::{fmt::Debug, ops::Deref};
 
 use crate::{
     error::Error,
-    ff::{PrimeField, RefOps},
+    ff::{PrimeField, },
     secret_sharing::Linear as LinearSecretSharing,
 };
+use crate::secret_sharing::RefOps;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct BitDecomposed<S> {
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 1ada1b8dd..ba99a9d9a 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -16,7 +16,7 @@ use rand::{
 };
 #[cfg(any(test, feature = "test-fixture", feature = "cli"))]
 use replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing};
-pub use scheme::{Bitwise, Linear, SecretSharing};
+pub use scheme::{Bitwise, Linear, SecretSharing, RefOps};
 
 use crate::ff::{ArithmeticOps, Serializable};
 
@@ -58,12 +58,13 @@ where
 #[cfg(all(test, unit_test))]
 mod tests {
     use crate::{
-        ff::{Fp31, RefOps},
+        ff::{Fp31, },
         secret_sharing::{
             replicated::{malicious, semi_honest},
             Linear, SharedValue,
         },
     };
+    use crate::secret_sharing::RefOps;
 
     fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>()
     where
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index 8d1502fa8..1025f7b7e 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -24,5 +24,34 @@ pub trait Linear<V: SharedValue>:
 {
 }
 
+/// The trait for arithmetic operations on references to a secret share, taking the
+/// second operand either by value or by reference. Secret sharings can be added/subtracted and
+/// multiplied by the shared values locally.
+///
+/// The need for this trait is dictated by [`rust-issue`] that causes us not being able to constrain
+/// references to `Self`. Once this issue is fixed, we can simply get rid of it.
+///
+/// This is automatically implemented for types which implement the operators. The idea is borrowed
+/// from [`RefNum`] trait, but I couldn't really make it work with HRTB and secret shares. Primitive
+/// types worked just fine though, so it is possible that it is another compiler issue.
+///
+/// [`RefNum`]: https://docs.rs/num/0.4.1/num/traits/trait.RefNum.html
+/// [`rust-issue`]: https://github.com/rust-lang/rust/issues/20671
+pub trait RefOps<'a, Base: 'a, R: 'a>:
+LocalArithmeticOps<Base, Base>
++ LocalArithmeticOps<&'a Base, Base>
++ Mul<R, Output = Base>
++ Mul<&'a R, Output = Base>
+{
+}
+impl<'a, T, Base: 'a, R: 'a> RefOps<'a, Base, R> for T where
+    T: LocalArithmeticOps<Base, Base>
+    + LocalArithmeticOps<&'a Base, Base>
+    + 'a
+    + Mul<R, Output = Base>
+    + Mul<&'a R, Output = Base>
+{
+}
+
 /// Secret share of a secret in bits. It has additive and multiplicative properties.
 pub trait Bitwise<V: GaloisField>: SecretSharing<V> + Linear<V> {}

From bc6690b82afe0ae9479d133d7fd9c0a165e621ed Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 28 Sep 2023 09:58:04 -0700
Subject: [PATCH 019/105] Move ArithmeticOps to shared value module

and rename RefOps to `LinearRefOps`
---
 src/ff/mod.rs                                 | 38 +++-------------
 src/protocol/aggregation/mod.rs               |  9 ++--
 .../attribution/apply_attribution_window.rs   | 11 +++--
 src/protocol/attribution/credit_capping.rs    | 13 +++---
 src/protocol/attribution/mod.rs               |  9 ++--
 src/protocol/basics/if_else.rs                |  7 ++-
 src/protocol/boolean/add_constant.rs          |  7 ++-
 src/protocol/boolean/bitwise_equal.rs         |  9 ++--
 src/protocol/boolean/comparison.rs            | 13 +++---
 src/protocol/boolean/random_bits_generator.rs |  7 ++-
 src/protocol/boolean/solved_bits.rs           |  7 ++-
 src/protocol/ipa/mod.rs                       |  7 ++-
 src/protocol/sort/bit_permutation.rs          |  7 ++-
 src/query/runner/aggregate.rs                 |  5 +--
 src/query/runner/ipa.rs                       |  7 ++-
 src/secret_sharing/decomposed.rs              |  7 ++-
 src/secret_sharing/mod.rs                     | 43 ++++++++++++++-----
 src/secret_sharing/scheme.rs                  | 29 ++++++-------
 18 files changed, 106 insertions(+), 129 deletions(-)

diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 49b11392e..fa3411580 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -6,7 +6,7 @@ mod field;
 mod galois_field;
 mod prime_field;
 
-use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+use std::ops::{Add, AddAssign, Sub, SubAssign};
 
 pub use field::{Field, FieldType};
 pub use galois_field::{GaloisField, Gf2, Gf32Bit, Gf3Bit, Gf40Bit, Gf8Bit};
@@ -21,45 +21,19 @@ pub enum Error {
     UnknownField { type_str: String },
 }
 
-/// Arithmetic operations that do not require communication in our MPC setting and can be performed
-/// locally.
-///
-/// Note: Neg operation is also local, but is causing issues when added as a bound to this trait.
-/// The problem is that it does not use `Rhs` generic and rustc overflows trying to compile functions
-/// that use HRTB generics bounded by `LocalArithmeticOps`.
-pub trait LocalArithmeticOps<Rhs = Self, Output = Self>:
+/// Addition and subtraction operations that are supported by secret sharings and shared values.
+pub trait AddSub<Rhs = Self, Output = Self>:
     Add<Rhs, Output = Output> + Sub<Rhs, Output = Output> + Sized
 {
 }
 
-impl<T, Rhs, Output> LocalArithmeticOps<Rhs, Output> for T where
+impl<T, Rhs, Output> AddSub<Rhs, Output> for T where
     T: Add<Rhs, Output = Output> + Sub<Rhs, Output = Output> + Sized
 {
 }
 
-pub trait LocalAssignOps<Rhs = Self>: AddAssign<Rhs> + SubAssign<Rhs> {}
-impl<T, Rhs> LocalAssignOps<Rhs> for T where T: AddAssign<Rhs> + SubAssign<Rhs> {}
-
-/// Arithmetic operations that may or may not require communication.
-/// for example, multiplying field values is a local operation, while multiplying secret shares is not.
-pub trait ArithmeticOps<Rhs = Self, Output = Self>:
-    LocalArithmeticOps<Rhs, Output>
-    + LocalAssignOps<Rhs>
-    + Mul<Rhs, Output = Output>
-    + MulAssign<Rhs>
-    + Neg<Output = Output>
-{
-}
-
-impl<T, Rhs, Output> ArithmeticOps<Rhs, Output> for T where
-    T: LocalArithmeticOps<Rhs, Output>
-        + LocalAssignOps<Rhs>
-        + Mul<Rhs, Output = Output>
-        + MulAssign<Rhs>
-        + Neg<Output = Output>
-{
-}
-
+pub trait AddSubAssign<Rhs = Self>: AddAssign<Rhs> + SubAssign<Rhs> {}
+impl<T, Rhs> AddSubAssign<Rhs> for T where T: AddAssign<Rhs> + SubAssign<Rhs> {}
 
 /// Trait for items that have fixed-byte length representation.
 pub trait Serializable: Sized {
diff --git a/src/protocol/aggregation/mod.rs b/src/protocol/aggregation/mod.rs
index 435234690..70e6a418f 100644
--- a/src/protocol/aggregation/mod.rs
+++ b/src/protocol/aggregation/mod.rs
@@ -19,11 +19,10 @@ use crate::{
             semi_honest::AdditiveShare as Replicated,
             ReplicatedSecretSharing,
         },
-        BitDecomposed, Linear as LinearSecretSharing,
+        BitDecomposed, Linear as LinearSecretSharing, LinearRefOps,
     },
     seq_join::seq_join,
 };
-use crate::secret_sharing::RefOps;
 
 // TODO: Use `#[derive(Step)]` once the protocol is implemented and the bench test is enabled.
 //       Once that is done, run `collect_steps.py` to generate `steps.txt` that includes these steps.
@@ -77,7 +76,7 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefOps<'r, S, F>,
+    for<'r> &'r S: LinearRefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2> + BasicProtocols<C::UpgradedContext<Gf2>, Gf2> + 'static,
     F: PrimeField + ExtendableField,
@@ -132,7 +131,7 @@ where
     I2: Stream<Item = Result<BitDecomposed<S>, Error>> + Send,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + Serializable + 'static,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     let equality_check_ctx = ctx.narrow(&Step::ComputeEqualityChecks);
 
@@ -175,7 +174,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + Serializable + 'static,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     let check_times_value_ctx = ctx.narrow(&Step::CheckTimesValue);
 
diff --git a/src/protocol/attribution/apply_attribution_window.rs b/src/protocol/attribution/apply_attribution_window.rs
index 0314f4d86..3bfef6c12 100644
--- a/src/protocol/attribution/apply_attribution_window.rs
+++ b/src/protocol/attribution/apply_attribution_window.rs
@@ -11,15 +11,14 @@ use super::{
 };
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, },
+    ff::{Field, PrimeField},
     protocol::{
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
         context::{Context, UpgradedContext},
         BasicProtocols, RecordId,
     },
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 /// This protocol applies the specified attribution window to trigger events. All trigger values of
 /// events that are outside the window will be replaced with 0, hence will not be attributed to
@@ -38,7 +37,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F> + 'static,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     if let Some(attribution_window_seconds) = attribution_window_seconds {
         let mut t_deltas = prefix_sum_time_deltas(&ctx, input, stop_bits).await?;
@@ -92,7 +91,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a T: RefOps<'a, T, F>,
+    for<'a> &'a T: LinearRefOps<'a, T, F>,
 {
     let num_rows = input.len();
 
@@ -152,7 +151,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     let ctx = ctx.set_total_records(input.len());
     let random_bits_generator =
diff --git a/src/protocol/attribution/credit_capping.rs b/src/protocol/attribution/credit_capping.rs
index bc37d76ad..4b9e91362 100644
--- a/src/protocol/attribution/credit_capping.rs
+++ b/src/protocol/attribution/credit_capping.rs
@@ -9,17 +9,16 @@ use ipa_macros::Step;
 use super::{do_the_binary_tree_thing, input::CreditCappingInputRow, prefix_or_binary_tree_style};
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, },
+    ff::{Field, PrimeField},
     protocol::{
         basics::{if_else, SecureMul},
         boolean::{greater_than_constant, random_bits_generator::RandomBitsGenerator},
         context::{Context, UpgradedContext},
         BasicProtocols, RecordId,
     },
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
     seq_join::seq_join,
 };
-use crate::secret_sharing::RefOps;
 
 /// User-level credit capping protocol.
 ///
@@ -36,7 +35,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     if cap == 1 {
         return Ok(credit_capping_max_one(ctx, input)
@@ -243,7 +242,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     let share_of_cap = S::share_known_value(&ctx, F::truncate_from(cap));
     let cap_ref = &share_of_cap;
@@ -298,7 +297,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(prefix_summed_credits.len());
@@ -361,7 +360,7 @@ where
     F: Field,
     C: Context,
     T: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a T: RefOps<'a, T, F>,
+    for<'a> &'a T: LinearRefOps<'a, T, F>,
 {
     let num_rows = input.len();
     let cap_share = T::share_known_value(&ctx, F::try_from(cap.into()).unwrap());
diff --git a/src/protocol/attribution/mod.rs b/src/protocol/attribution/mod.rs
index 3be107298..bad651407 100644
--- a/src/protocol/attribution/mod.rs
+++ b/src/protocol/attribution/mod.rs
@@ -35,11 +35,10 @@ use crate::{
             malicious::{DowngradeMalicious, ExtendableField},
             semi_honest::AdditiveShare as Replicated,
         },
-        Linear as LinearSecretSharing,
+        Linear as LinearSecretSharing, LinearRefOps,
     },
     seq_join::assert_send,
 };
-use crate::secret_sharing::RefOps;
 
 /// Performs a set of attribution protocols on the sorted IPA input.
 ///
@@ -63,13 +62,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB> + Context,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for<'a> &'a SB: RefOps<'a, SB, Gf2>,
+    for<'a> &'a SB: LinearRefOps<'a, SB, Gf2>,
     F: PrimeField + ExtendableField,
     ShuffledPermutationWrapper<S, C::UpgradedContext<F>>: DowngradeMalicious<Target = Vec<u32>>,
 {
@@ -406,7 +405,7 @@ async fn compute_helper_bits_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for<'a> &'a S: RefOps<'a, S, Gf2>,
+    for<'a> &'a S: LinearRefOps<'a, S, Gf2>,
 {
     let narrowed_ctx = ctx
         .narrow(&Step::ComputeHelperBits)
diff --git a/src/protocol/basics/if_else.rs b/src/protocol/basics/if_else.rs
index 265ee179f..3fe486983 100644
--- a/src/protocol/basics/if_else.rs
+++ b/src/protocol/basics/if_else.rs
@@ -1,10 +1,9 @@
 use crate::{
     error::Error,
-    ff::{Field, },
+    ff::Field,
     protocol::{basics::SecureMul, context::Context, RecordId},
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 /// Returns `true_value` if `condition` is a share of 1, else `false_value`.
 /// # Errors
@@ -20,7 +19,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + SecureMul<C>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     // If `condition` is a share of 1 (true), then
     //   = false_value + 1 * (true_value - false_value)
diff --git a/src/protocol/boolean/add_constant.rs b/src/protocol/boolean/add_constant.rs
index fa5c35185..74a11fb44 100644
--- a/src/protocol/boolean/add_constant.rs
+++ b/src/protocol/boolean/add_constant.rs
@@ -1,10 +1,9 @@
 use crate::{
     error::Error,
-    ff::{Field, },
+    ff::Field,
     protocol::{context::Context, step::BitOpStep, BasicProtocols, RecordId},
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 /// This is an implementation of a Bitwise Sum of a bitwise-shared number with a constant.
 ///
@@ -53,7 +52,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     let mut output = Vec::with_capacity(a.len() + 1);
 
diff --git a/src/protocol/boolean/bitwise_equal.rs b/src/protocol/boolean/bitwise_equal.rs
index e305ef748..0fca8f101 100644
--- a/src/protocol/boolean/bitwise_equal.rs
+++ b/src/protocol/boolean/bitwise_equal.rs
@@ -2,11 +2,10 @@ use std::iter::zip;
 
 use crate::{
     error::Error,
-    ff::{Field, Gf2, },
+    ff::{Field, Gf2},
     protocol::{boolean::all_zeroes, context::Context, BasicProtocols, RecordId},
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 /// Compares `[a]` and `c`, and returns 1 iff `a == c`
 ///
@@ -25,7 +24,7 @@ where
     F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -58,7 +57,7 @@ pub async fn bitwise_equal_gf2<C, S>(
 where
     C: Context,
     S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
-    for<'a> &'a S: RefOps<'a, S, Gf2>,
+    for<'a> &'a S: LinearRefOps<'a, S, Gf2>,
 {
     debug_assert!(a.len() == b.len());
     let c = zip(a.iter(), b.iter())
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 273e6b87c..6d7360b2d 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -3,16 +3,15 @@ use ipa_macros::Step;
 use super::or::or;
 use crate::{
     error::Error,
-    ff::{PrimeField, },
+    ff::PrimeField,
     protocol::{
         boolean::random_bits_generator::RandomBitsGenerator,
         context::{Context, UpgradedContext},
         step::BitOpStep,
         BasicProtocols, RecordId,
     },
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 // Compare an arithmetic-shared value `a` to a known value `c`.
 //
@@ -74,7 +73,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     use GreaterThanConstantStep as Step;
 
@@ -176,7 +175,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -209,7 +208,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     assert!(a.len() <= 128);
 
@@ -240,7 +239,7 @@ where
     F: PrimeField,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     let one = S::share_known_value(ctx, F::ONE);
 
diff --git a/src/protocol/boolean/random_bits_generator.rs b/src/protocol/boolean/random_bits_generator.rs
index 4ed99bf8e..df99f62ba 100644
--- a/src/protocol/boolean/random_bits_generator.rs
+++ b/src/protocol/boolean/random_bits_generator.rs
@@ -7,16 +7,15 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{PrimeField, },
+    ff::PrimeField,
     helpers::TotalRecords,
     protocol::{
         boolean::solved_bits::{solved_bits, RandomBitsShare},
         context::UpgradedContext,
         BasicProtocols, RecordId,
     },
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 /// A struct that generates random sharings of bits from the
 /// `SolvedBits` protocol. Any protocol who wish to use a random-bits can draw
@@ -45,7 +44,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     #[must_use]
     pub fn new(ctx: C) -> Self {
diff --git a/src/protocol/boolean/solved_bits.rs b/src/protocol/boolean/solved_bits.rs
index a113b8323..2e3ef1b07 100644
--- a/src/protocol/boolean/solved_bits.rs
+++ b/src/protocol/boolean/solved_bits.rs
@@ -5,7 +5,7 @@ use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{Field, PrimeField, },
+    ff::{Field, PrimeField},
     protocol::{
         boolean::{
             bitwise_less_than_prime::BitwiseLessThanPrime, generate_random_bits::one_random_bit,
@@ -18,10 +18,9 @@ use crate::{
             AdditiveShare as MaliciousReplicated, DowngradeMalicious, ExtendableField,
             UnauthorizedDowngradeWrapper,
         },
-        BitDecomposed, Linear as LinearSecretSharing, SecretSharing,
+        BitDecomposed, Linear as LinearSecretSharing, LinearRefOps, SecretSharing,
     },
 };
-use crate::secret_sharing::RefOps;
 
 #[derive(Debug)]
 pub struct RandomBitsShare<F, S>
@@ -95,7 +94,7 @@ where
     F: PrimeField,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
-    for<'a> &'a S: RefOps<'a, S, F>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
 {
     //
     // step 1 & 2
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index 4cd392f91..daa5f68f8 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -35,10 +35,9 @@ use crate::{
             semi_honest::AdditiveShare as Replicated,
             ReplicatedSecretSharing,
         },
-        BitDecomposed, Linear as LinearSecretSharing,
+        BitDecomposed, Linear as LinearSecretSharing, LinearRefOps,
     },
 };
-use crate::secret_sharing::RefOps;
 
 #[derive(Step)]
 pub(crate) enum Step {
@@ -316,13 +315,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefOps<'r, S, F>,
+    for<'r> &'r S: LinearRefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for<'r> &'r SB: RefOps<'r, SB, Gf2>,
+    for<'r> &'r SB: LinearRefOps<'r, SB, Gf2>,
     F: PrimeField + ExtendableField,
     MK: GaloisField,
     BK: GaloisField,
diff --git a/src/protocol/sort/bit_permutation.rs b/src/protocol/sort/bit_permutation.rs
index 95a860ce7..97058e3cd 100644
--- a/src/protocol/sort/bit_permutation.rs
+++ b/src/protocol/sort/bit_permutation.rs
@@ -4,11 +4,10 @@ use embed_doc_image::embed_doc_image;
 
 use crate::{
     error::Error,
-    ff::{Field, },
+    ff::Field,
     protocol::{context::Context, BasicProtocols, RecordId},
-    secret_sharing::Linear as LinearSecretSharing,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 #[embed_doc_image("bit_permutation", "images/sort/bit_permutations.png")]
 /// This is an implementation of `GenBitPerm` (Algorithm 3) described in:
@@ -42,7 +41,7 @@ pub async fn bit_permutation<
     input: &[S],
 ) -> Result<Vec<S>, Error>
 where
-    for<'r> &'r S: RefOps<'r, S, F>,
+    for<'r> &'r S: LinearRefOps<'r, S, F>,
 {
     let ctx_ref = &ctx;
     let ctx = ctx.set_total_records(2 * input.len());
diff --git a/src/query/runner/aggregate.rs b/src/query/runner/aggregate.rs
index 03aacf218..e0dee3550 100644
--- a/src/query/runner/aggregate.rs
+++ b/src/query/runner/aggregate.rs
@@ -19,11 +19,10 @@ use crate::{
     },
     secret_sharing::{
         replicated::{malicious::DowngradeMalicious, semi_honest::AdditiveShare as Replicated},
-        Linear as LinearSecretSharing,
+        Linear as LinearSecretSharing, LinearRefOps,
     },
     sync::Arc,
 };
-use crate::secret_sharing::RefOps;
 
 pub struct SparseAggregateQuery<F, C, S> {
     config: SparseAggregateQueryConfig,
@@ -54,7 +53,7 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefOps<'r, S, F>,
+    for<'r> &'r S: LinearRefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
diff --git a/src/query/runner/ipa.rs b/src/query/runner/ipa.rs
index 482e5637b..2b19ead23 100644
--- a/src/query/runner/ipa.rs
+++ b/src/query/runner/ipa.rs
@@ -24,11 +24,10 @@ use crate::{
     report::{EncryptedReport, EventType, InvalidReportError},
     secret_sharing::{
         replicated::{malicious::DowngradeMalicious, semi_honest::AdditiveShare as Replicated},
-        Linear as LinearSecretSharing,
+        Linear as LinearSecretSharing, LinearRefOps,
     },
     sync::Arc,
 };
-use crate::secret_sharing::RefOps;
 
 pub struct IpaQuery<F, C, S> {
     config: IpaQueryConfig,
@@ -56,13 +55,13 @@ where
         + Serializable
         + DowngradeMalicious<Target = Replicated<F>>
         + 'static,
-    for<'r> &'r S: RefOps<'r, S, F>,
+    for<'r> &'r S: LinearRefOps<'r, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = SB>,
     SB: LinearSecretSharing<Gf2>
         + BasicProtocols<C::UpgradedContext<Gf2>, Gf2>
         + DowngradeMalicious<Target = Replicated<Gf2>>
         + 'static,
-    for<'r> &'r SB: RefOps<'r, SB, Gf2>,
+    for<'r> &'r SB: LinearRefOps<'r, SB, Gf2>,
     F: PrimeField,
     Replicated<F>: Serializable + ShareKnownValue<C, F>,
     IPAInputRow<F, MatchKey, BreakdownKey>: Serializable,
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index e5ccc630b..44aa83238 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -2,10 +2,9 @@ use std::{fmt::Debug, ops::Deref};
 
 use crate::{
     error::Error,
-    ff::{PrimeField, },
-    secret_sharing::Linear as LinearSecretSharing,
+    ff::PrimeField,
+    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
-use crate::secret_sharing::RefOps;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct BitDecomposed<S> {
@@ -61,7 +60,7 @@ impl<S> BitDecomposed<S> {
     pub fn to_additive_sharing_in_large_field<F>(&self) -> S
     where
         S: LinearSecretSharing<F>,
-        for<'a> &'a S: RefOps<'a, S, F>,
+        for<'a> &'a S: LinearRefOps<'a, S, F>,
         F: PrimeField,
     {
         self.iter().enumerate().fold(S::ZERO, |acc, (i, b)| {
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index ba99a9d9a..908a45feb 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -4,7 +4,10 @@ mod decomposed;
 mod into_shares;
 mod scheme;
 
-use std::fmt::Debug;
+use std::{
+    fmt::Debug,
+    ops::{Mul, MulAssign, Neg},
+};
 
 pub use decomposed::BitDecomposed;
 use generic_array::ArrayLength;
@@ -16,9 +19,28 @@ use rand::{
 };
 #[cfg(any(test, feature = "test-fixture", feature = "cli"))]
 use replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing};
-pub use scheme::{Bitwise, Linear, SecretSharing, RefOps};
+pub use scheme::{Bitwise, Linear, LinearRefOps, SecretSharing};
+
+use crate::ff::{AddSub, AddSubAssign, Serializable};
 
-use crate::ff::{ArithmeticOps, Serializable};
+/// Operations supported for shared values.
+pub trait Arithmetic<Rhs = Self, Output = Self>:
+    AddSub<Rhs, Output>
+    + AddSubAssign<Rhs>
+    + Mul<Rhs, Output = Output>
+    + MulAssign<Rhs>
+    + Neg<Output = Output>
+{
+}
+
+impl<T, Rhs, Output> Arithmetic<Rhs, Output> for T where
+    T: AddSub<Rhs, Output>
+        + AddSubAssign<Rhs>
+        + Mul<Rhs, Output = Output>
+        + MulAssign<Rhs>
+        + Neg<Output = Output>
+{
+}
 
 // Trait for primitive integer types used to represent the underlying type for shared values
 pub trait Block: Sized + Copy + Debug {
@@ -27,7 +49,7 @@ pub trait Block: Sized + Copy + Debug {
 }
 
 pub trait SharedValue:
-    Clone + Copy + PartialEq + Debug + Send + Sync + Sized + ArithmeticOps + Serializable + 'static
+    Clone + Copy + PartialEq + Debug + Send + Sync + Sized + Arithmetic + Serializable + 'static
 {
     type Storage: Block;
 
@@ -58,17 +80,16 @@ where
 #[cfg(all(test, unit_test))]
 mod tests {
     use crate::{
-        ff::{Fp31, },
+        ff::Fp31,
         secret_sharing::{
             replicated::{malicious, semi_honest},
-            Linear, SharedValue,
+            Linear, LinearRefOps, SharedValue,
         },
     };
-    use crate::secret_sharing::RefOps;
 
     fn arithmetic<L: Linear<V> + PartialEq, V: SharedValue>()
     where
-        for<'a> &'a L: RefOps<'a, L, V>,
+        for<'a> &'a L: LinearRefOps<'a, L, V>,
     {
         let a = L::ZERO;
         let b = L::ZERO;
@@ -81,7 +102,7 @@ mod tests {
 
     fn trait_bounds<L: Linear<V> + PartialEq, V: SharedValue>()
     where
-        for<'a> &'a L: RefOps<'a, L, V>,
+        for<'a> &'a L: LinearRefOps<'a, L, V>,
     {
         fn sum_owned<S: Linear<V>, V: SharedValue>(a: S, b: S) -> S {
             a + b
@@ -91,7 +112,7 @@ mod tests {
         where
             S: Linear<V>,
             V: SharedValue,
-            for<'a> &'a S: RefOps<'a, S, V>,
+            for<'a> &'a S: LinearRefOps<'a, S, V>,
         {
             a + b
         }
@@ -104,7 +125,7 @@ mod tests {
         where
             S: Linear<V>,
             V: SharedValue,
-            for<'a> &'a S: RefOps<'a, S, V>,
+            for<'a> &'a S: LinearRefOps<'a, S, V>,
         {
             a + b
         }
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index 1025f7b7e..cd6556211 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -4,7 +4,7 @@ use std::{
 };
 
 use super::SharedValue;
-use crate::ff::{GaloisField, LocalArithmeticOps, LocalAssignOps};
+use crate::ff::{AddSub, AddSubAssign, GaloisField};
 
 /// Secret sharing scheme i.e. Replicated secret sharing
 pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
@@ -14,10 +14,10 @@ pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
 /// Secret share of a secret that has additive and multiplicative properties.
 pub trait Linear<V: SharedValue>:
     SecretSharing<V>
-    + LocalArithmeticOps
-    + LocalAssignOps
-    + for<'r> LocalArithmeticOps<&'r Self>
-    + for<'r> LocalAssignOps<&'r Self>
+    + AddSub
+    + AddSubAssign
+    + for<'r> AddSub<&'r Self>
+    + for<'r> AddSubAssign<&'r Self>
     + Mul<V, Output = Self>
     + for<'r> Mul<&'r V, Output = Self>
     + Neg<Output = Self>
@@ -37,19 +37,16 @@ pub trait Linear<V: SharedValue>:
 ///
 /// [`RefNum`]: https://docs.rs/num/0.4.1/num/traits/trait.RefNum.html
 /// [`rust-issue`]: https://github.com/rust-lang/rust/issues/20671
-pub trait RefOps<'a, Base: 'a, R: 'a>:
-LocalArithmeticOps<Base, Base>
-+ LocalArithmeticOps<&'a Base, Base>
-+ Mul<R, Output = Base>
-+ Mul<&'a R, Output = Base>
+pub trait LinearRefOps<'a, Base: 'a, R: 'a>:
+    AddSub<Base, Base> + AddSub<&'a Base, Base> + Mul<R, Output = Base> + Mul<&'a R, Output = Base>
 {
 }
-impl<'a, T, Base: 'a, R: 'a> RefOps<'a, Base, R> for T where
-    T: LocalArithmeticOps<Base, Base>
-    + LocalArithmeticOps<&'a Base, Base>
-    + 'a
-    + Mul<R, Output = Base>
-    + Mul<&'a R, Output = Base>
+impl<'a, T, Base: 'a, R: 'a> LinearRefOps<'a, Base, R> for T where
+    T: AddSub<Base, Base>
+        + AddSub<&'a Base, Base>
+        + 'a
+        + Mul<R, Output = Base>
+        + Mul<&'a R, Output = Base>
 {
 }
 

From 16e8768361acf9f27c5456264f12529fdce3616e Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 28 Sep 2023 10:05:45 -0700
Subject: [PATCH 020/105] Fix clones in saturating sum module

---
 src/protocol/boolean/saturating_sum.rs | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/protocol/boolean/saturating_sum.rs b/src/protocol/boolean/saturating_sum.rs
index c3ae098b3..f57551d98 100644
--- a/src/protocol/boolean/saturating_sum.rs
+++ b/src/protocol/boolean/saturating_sum.rs
@@ -2,7 +2,7 @@ use crate::{
     error::Error,
     ff::{Field, Gf2},
     protocol::{boolean::or::or, context::Context, step::BitOpStep, BasicProtocols, RecordId},
-    secret_sharing::{BitDecomposed, Linear as LinearSecretSharing},
+    secret_sharing::{BitDecomposed, Linear as LinearSecretSharing, LinearRefOps},
 };
 
 #[derive(Debug)]
@@ -34,6 +34,7 @@ impl<S: LinearSecretSharing<Gf2>> SaturatingSum<S> {
     where
         C: Context,
         S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
+        for<'a> &'a S: LinearRefOps<'a, S, Gf2>,
     {
         assert!(self.sum.len() >= value.len());
 
@@ -84,6 +85,7 @@ impl<S: LinearSecretSharing<Gf2>> SaturatingSum<S> {
     where
         C: Context,
         S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
+        for<'a> &'a S: LinearRefOps<'a, S, Gf2>,
     {
         assert!(num_bits as usize <= self.sum.len());
 
@@ -136,12 +138,13 @@ async fn one_bit_adder<C, SB>(
 where
     C: Context,
     SB: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
+    for<'a> &'a SB: LinearRefOps<'a, SB, Gf2>,
 {
     // compute sum bit as x XOR y XOR carry_in
-    let sum_bit = x.clone() + y + carry_in;
+    let sum_bit = x + y + &*carry_in;
 
-    let x_xor_carry_in = x.clone() + carry_in;
-    let y_xor_carry_in = y.clone() + carry_in;
+    let x_xor_carry_in = x + &*carry_in;
+    let y_xor_carry_in = y + &*carry_in;
 
     // There are two cases when the `carry_out` bit is different from the `carry_in` bit
     // (1) When the `carry_in` bit is 0 and both `x` and `y` are 1
@@ -150,7 +153,7 @@ where
     *carry_in = x_xor_carry_in
         .multiply(&y_xor_carry_in, ctx, record_id)
         .await?
-        + carry_in;
+        + &*carry_in;
 
     Ok(sum_bit)
 }
@@ -183,18 +186,19 @@ async fn one_bit_subtractor<C, SB>(
 where
     C: Context,
     SB: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
+    for<'a> &'a SB: LinearRefOps<'a, SB, Gf2>,
 {
     // compute difference bit as not_y XOR x XOR carry_in
-    let difference_bit = SB::share_known_value(&ctx, Gf2::ONE) + y + x + carry_in;
+    let difference_bit = SB::share_known_value(&ctx, Gf2::ONE) + y + x + &*carry_in;
     if compute_carry_out {
-        let x_xor_carry_in = x.clone() + carry_in;
-        let y_xor_carry_in = y.clone() + carry_in;
+        let x_xor_carry_in = x + &*carry_in;
+        let y_xor_carry_in = y + &*carry_in;
         let not_y_xor_carry_in = SB::share_known_value(&ctx, Gf2::ONE) + &y_xor_carry_in;
 
         *carry_in = x_xor_carry_in
             .multiply(&not_y_xor_carry_in, ctx, record_id)
             .await?
-            + carry_in;
+            + &*carry_in;
     }
     Ok(difference_bit)
 }

From cc64e829bb52bab459703cb19ccadf263805583f Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Fri, 29 Sep 2023 12:52:14 +0800
Subject: [PATCH 021/105] cannot do converted_bks.next on a stream

---
 src/protocol/prf_sharding/mod.rs | 72 ++++++++++++++++----------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 0fa66e41f..fe8de2875 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1,14 +1,13 @@
 use std::iter::{repeat, zip};
 
-use futures_util::{future::try_join, StreamExt};
+use futures_util::{future::try_join, Stream, StreamExt};
 use ipa_macros::Step;
 
 use super::{
-    basics::{if_else, mul::malicious::multiply},
+    basics::{if_else},
     boolean::saturating_sum::SaturatingSum,
-    modulus_conversion::convert_bits,
+    modulus_conversion::{convert_bits, ToBitConversionTriples},
     step::BitOpStep,
-    BasicProtocols,
 };
 use futures::stream::unfold;
 
@@ -281,7 +280,7 @@ pub async fn attribution_and_capping_and_aggregation<C, BK, TV, F, S, SB>(
 where
     C: UpgradableContext,
     C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + BasicProtocols<C, F>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F> >,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
     F: PrimeField + ExtendableField,
     TV: GaloisField,
@@ -295,8 +294,7 @@ where
     let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
     let prime_field_m_ctx = prime_field_validator.context();
 
-    // call aggregation protocol which checks onehot and multiplies value to each bucket
-
+   
     do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
 }
 
@@ -306,20 +304,22 @@ async fn do_aggregation<C, BK, TV, F, S>(
 ) -> Result<Vec<Replicated<F>>, Error>
 where
     C: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + BasicProtocols<C, F>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
     BK: GaloisField,
     TV: GaloisField,
     F: PrimeField + ExtendableField,
 {
-    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
-        .into_iter()
-        .map(|row| {
-            (
-                row.attributed_breakdown_key_bits,
-                row.capped_attributed_trigger_value,
-            )
-        })
-        .unzip();
+     // call aggregation protocol which checks onehot and multiplies value to each bucket
+
+     let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
+     .into_iter()
+     .map(|row| {
+         (
+             row.attributed_breakdown_key_bits,
+             row.capped_attributed_trigger_value,
+         )
+     })
+     .unzip();
 
     // convert bk
     // TODO fix set_total_records
@@ -341,25 +341,25 @@ where
     let large_field_value =
         converted_values.map(|val| val.unwrap().to_additive_sharing_in_large_field());
 
-    // let stream = unfold(
-    //     (ctx, converted_bks, large_field_value, RecordId(0)),
-    //     |(ctx, mut converted_bks, mut large_field_value, record_id)| async move {
-    //         let Some(bk_bits) = converted_bks.next().await else {
-    //             return None;
-    //         };
-    //         let Some(val) = large_field_value.next().await else {
-    //             return None;
-    //         };
-    //         let output = bk_bits.unwrap()[0].multiply(val, ctx, record_id);
-
-    //         Some((
-    //             output,
-    //             (ctx, converted_bks, large_field_value, record_id + 1),
-    //         ))
-    //     },
-    // );
-    // seq_join(ctx.active_work(), stream).await;
-    // Some((converted, (ctx, locally_converted, record_id + 1)))
+    let stream = unfold(
+        (ctx, converted_bks, RecordId(0)),
+        |(ctx, mut converted_bks, record_id)| async move {
+            let Some(bk_bits) = converted_bks.next().await else {
+                return None;
+            };
+            let Some(val) = large_field_value.next().await else {
+                return None;
+            };
+            let output = bk_bits.unwrap()[0].multiply(&S::ZERO, ctx, record_id).await.unwrap();
+
+            Some((
+                output,
+                (ctx, converted_bks, record_id + 1)
+            ))
+        },
+    );
+    seq_join(ctx.active_work(), stream).await;
+    
     Ok(vec![])
     // tree_aggregate_credit(ctx, converted_bks, large_field_value, 1 << BK::BITS).await
 }

From ef582e8bf2b66fa4973466deba2081a6a362d040 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Fri, 29 Sep 2023 15:40:33 +0800
Subject: [PATCH 022/105] Aggregating the attribution and capping results

---
 src/protocol/attribution/aggregate_credit.rs |   2 +-
 src/protocol/prf_sharding/mod.rs             | 194 +++++++++++++------
 2 files changed, 141 insertions(+), 55 deletions(-)

diff --git a/src/protocol/attribution/aggregate_credit.rs b/src/protocol/attribution/aggregate_credit.rs
index a038875e0..6d607b1c1 100644
--- a/src/protocol/attribution/aggregate_credit.rs
+++ b/src/protocol/attribution/aggregate_credit.rs
@@ -68,7 +68,7 @@ where
     }
 }
 
-pub async fn simple_aggregate_credit<F, C, IC, IB, S>(
+async fn simple_aggregate_credit<F, C, IC, IB, S>(
     ctx: C,
     breakdown_keys: IB,
     capped_credits: IC,
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index fe8de2875..fc42ee882 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1,15 +1,13 @@
 use std::iter::{repeat, zip};
 
-use futures_util::{future::try_join, Stream, StreamExt};
+use futures_util::{future::try_join, StreamExt};
 use ipa_macros::Step;
 
 use super::{
-    basics::{if_else},
-    boolean::saturating_sum::SaturatingSum,
-    modulus_conversion::{convert_bits, ToBitConversionTriples},
+    basics::if_else, boolean::saturating_sum::SaturatingSum, modulus_conversion::convert_bits,
     step::BitOpStep,
 };
-use futures::stream::unfold;
+use futures::{stream::iter as stream_iter, TryStreamExt};
 
 use crate::{
     error::Error,
@@ -29,7 +27,6 @@ use crate::{
     },
     seq_join::{seq_join, seq_try_join_all},
 };
-use futures::stream::iter as stream_iter;
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {
     prf_of_match_key: u64,
     is_trigger_bit: Replicated<Gf2>,
@@ -211,9 +208,7 @@ pub(crate) enum Step {
     ComputedCappedAttributedTriggerValueJustSaturatedCase,
     ComputedAttributedBreakdownKey,
     ComputedAttributedValue,
-    ComputeEqualityChecks,
-    CheckTimesCredit,
-    AttributionAndCapping,
+    MoveValueToCorrectBreakdown,
 }
 
 fn compute_histogram_of_users_with_row_count<S>(rows_chunked_by_user: &[Vec<S>]) -> Vec<usize> {
@@ -272,20 +267,21 @@ where
     rows_chunked_by_user
 }
 
+/// # Errors
+/// If there is an issue in multiplication, it will error
 pub async fn attribution_and_capping_and_aggregation<C, BK, TV, F, S, SB>(
     sh_ctx: C,
     input_rows: Vec<PrfShardedIpaInputRow<BK, TV>>,
     num_saturating_sum_bits: usize,
-) -> Result<Vec<Replicated<F>>, Error>
+) -> Result<Vec<S>, Error>
 where
     C: UpgradableContext,
     C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F> >,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F>>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
     F: PrimeField + ExtendableField,
     TV: GaloisField,
     BK: GaloisField,
-    //for<'u> UpgradeContext<'u, C::UpgradedContext<F>, F, RecordId>: UpgradeToMalicious<'u, BitConversionTriple<Replicated<F>>, BitConversionTriple<S>>
 {
     // Call attribution_and_capping
     let user_level_attributions: Vec<CappedAttributionOutputs> =
@@ -294,14 +290,25 @@ where
     let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
     let prime_field_m_ctx = prime_field_validator.context();
 
-   
     do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
 }
 
+#[derive(Step)]
+pub enum BinaryTreeDepthStep {
+    #[dynamic]
+    Depth(usize),
+}
+
+impl From<usize> for BinaryTreeDepthStep {
+    fn from(v: usize) -> Self {
+        Self::Depth(v)
+    }
+}
+
 async fn do_aggregation<C, BK, TV, F, S>(
     ctx: C,
     user_level_attributions: Vec<CappedAttributionOutputs>,
-) -> Result<Vec<Replicated<F>>, Error>
+) -> Result<Vec<S>, Error>
 where
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
@@ -309,60 +316,87 @@ where
     TV: GaloisField,
     F: PrimeField + ExtendableField,
 {
-     // call aggregation protocol which checks onehot and multiplies value to each bucket
-
-     let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
-     .into_iter()
-     .map(|row| {
-         (
-             row.attributed_breakdown_key_bits,
-             row.capped_attributed_trigger_value,
-         )
-     })
-     .unzip();
+    let num_records = user_level_attributions.len();
+    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
+        .into_iter()
+        .map(|row| {
+            (
+                row.attributed_breakdown_key_bits,
+                row.capped_attributed_trigger_value,
+            )
+        })
+        .unzip();
 
     // convert bk
-    // TODO fix set_total_records
     let converted_bks = convert_bits(
-        ctx.narrow(&Step::ComputedAttributedBreakdownKey),
-        // .set_total_records(BK::BITS.into()),
+        ctx.narrow(&Step::ComputedAttributedBreakdownKey)
+            .set_total_records(num_records),
         stream_iter(bk_vec),
         0..BK::BITS,
     );
     // convert attributed value
-    // TODO fix set_total_records
-
     let converted_values = convert_bits(
-        ctx.narrow(&Step::ComputedAttributedValue),
-        // .set_total_records(TV::BITS.into()),
+        ctx.narrow(&Step::ComputedAttributedValue)
+            .set_total_records(num_records),
         stream_iter(tv_vec),
         0..TV::BITS,
     );
     let large_field_value =
         converted_values.map(|val| val.unwrap().to_additive_sharing_in_large_field());
 
-    let stream = unfold(
-        (ctx, converted_bks, RecordId(0)),
-        |(ctx, mut converted_bks, record_id)| async move {
-            let Some(bk_bits) = converted_bks.next().await else {
-                return None;
-            };
-            let Some(val) = large_field_value.next().await else {
-                return None;
-            };
-            let output = bk_bits.unwrap()[0].multiply(&S::ZERO, ctx, record_id).await.unwrap();
-
-            Some((
-                output,
-                (ctx, converted_bks, record_id + 1)
-            ))
-        },
-    );
-    seq_join(ctx.active_work(), stream).await;
-    
-    Ok(vec![])
-    // tree_aggregate_credit(ctx, converted_bks, large_field_value, 1 << BK::BITS).await
+    let row_contributions_stream = converted_bks
+        .zip(large_field_value)
+        .zip(futures::stream::repeat(
+            ctx.narrow(&Step::MoveValueToCorrectBreakdown)
+                .set_total_records(num_records),
+        ))
+        .enumerate()
+        .map(|(i, ((bk_bits, cred), ctx))| {
+            let mut row_contribution = vec![cred.clone(); 1 << BK::BITS];
+            let mut step: usize = 1 << BK::BITS;
+            let record_id: RecordId = RecordId::from(i);
+            let bd_key = bk_bits.unwrap();
+            async move {
+                for (tree_depth, bit_of_bdkey) in bd_key.iter().rev().enumerate() {
+                    let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
+                    let span = step >> 1;
+                    let mut futures = vec![];
+                    for i in (0..1 << BK::BITS).step_by(step) {
+                        let bit_c = depth_c.narrow(&BitOpStep::from(i));
+
+                        if i + span < 1 << BK::BITS {
+                            let vb = row_contribution[i].multiply(bit_of_bdkey, bit_c, record_id);
+                            futures.push(vb);
+                        }
+                    }
+                    let vbs = ctx.parallel_join(futures).await?;
+
+                    for (index, vb) in vbs.into_iter().enumerate() {
+                        let left_index = index * step;
+                        let right_index = left_index + span;
+
+                        row_contribution[left_index] -= &vb;
+                        row_contribution[right_index] = vb;
+                    }
+                    step = span;
+                }
+                Ok(row_contribution)
+            }
+        });
+    let row_contributions = seq_join(ctx.active_work(), row_contributions_stream);
+    row_contributions
+        .try_fold(
+            vec![S::ZERO; 1 << BK::BITS],
+            |mut running_sums, row_contribution| async move {
+                for (i, contribution) in row_contribution.iter().enumerate() {
+                    running_sums[i] += contribution;
+                }
+                Ok(running_sums)
+            },
+        )
+        .await
 }
+
 /// Sub-protocol of the PRF-sharded IPA Protocol
 ///
 /// After the computation of the per-user PRF, addition of dummy records and shuffling,
@@ -633,7 +667,8 @@ where
 pub mod tests {
     use super::{attribution_and_capping, CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
-        ff::{Field, GaloisField, Gf2, Gf3Bit, Gf5Bit},
+        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf3Bit, Gf5Bit},
+        protocol::prf_sharding::attribution_and_capping_and_aggregation,
         rand::Rng,
         secret_sharing::{
             replicated::semi_honest::AdditiveShare as Replicated, BitDecomposed, IntoShares,
@@ -813,4 +848,55 @@ pub mod tests {
             assert_eq!(result, &expected);
         });
     }
+
+    #[test]
+    fn semi_honest_aggregation() {
+        run(|| async move {
+            let world = TestWorld::default();
+
+            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit>> = vec![
+                /* First User */
+                test_input(123, false, 17, 0),
+                test_input(123, true, 0, 7),
+                test_input(123, false, 20, 0),
+                test_input(123, true, 0, 3),
+                /* Second User */
+                test_input(234, false, 12, 0),
+                test_input(234, true, 0, 5),
+                /* Third User */
+                test_input(345, false, 20, 0),
+                test_input(345, true, 0, 7),
+                test_input(345, false, 18, 0),
+                test_input(345, false, 12, 0),
+                test_input(345, true, 0, 7),
+                test_input(345, true, 0, 7),
+                test_input(345, true, 0, 7),
+                test_input(345, true, 0, 7),
+            ];
+
+            let mut expected = [0_u128; 32];
+            expected[12] = 30;
+            expected[17] = 7;
+            expected[20] = 10;
+
+            let num_saturating_bits: usize = 5;
+
+            let result: Vec<_> = world
+                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
+                    attribution_and_capping_and_aggregation::<
+                        _,
+                        Gf5Bit,
+                        Gf3Bit,
+                        Fp32BitPrime,
+                        _,
+                        Replicated<Gf2>,
+                    >(ctx, input_rows, num_saturating_bits)
+                    .await
+                    .unwrap()
+                })
+                .await
+                .reconstruct();
+            assert_eq!(result, &expected);
+        });
+    }
 }

From 9c00477f24240138b18d1641988653a9a56504b5 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Fri, 29 Sep 2023 17:10:03 +0800
Subject: [PATCH 023/105] Merge issues

---
 src/protocol/prf_sharding/mod.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 9f8866d09..c4ef2a633 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -22,7 +22,7 @@ use crate::{
             malicious::ExtendableField, semi_honest::AdditiveShare as Replicated,
             ReplicatedSecretSharing,
         },
-        BitDecomposed, Linear as LinearSecretSharing, SharedValue,
+        BitDecomposed, Linear as LinearSecretSharing, LinearRefOps, SharedValue,
     },
     seq_join::{seq_join, seq_try_join_all},
 };
@@ -277,6 +277,7 @@ where
     C: UpgradableContext,
     C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F>>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
     F: PrimeField + ExtendableField,
     TV: GaloisField,
@@ -311,6 +312,7 @@ async fn do_aggregation<C, BK, TV, F, S>(
 where
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
+    for<'a> &'a S: LinearRefOps<'a, S, F>,
     BK: GaloisField,
     TV: GaloisField,
     F: PrimeField + ExtendableField,

From 071cb7839badf30e9a672fe3d9ec437ff7252268 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Mon, 2 Oct 2023 12:46:44 +0800
Subject: [PATCH 024/105] Incorporate Ben's feedback

---
 images/tree_aggregation.png      | Bin 0 -> 104285 bytes
 src/protocol/aggregation/mod.rs  |   4 +-
 src/protocol/prf_sharding/mod.rs | 323 +++++++++++++++++--------------
 src/secret_sharing/decomposed.rs |  12 ++
 4 files changed, 196 insertions(+), 143 deletions(-)
 create mode 100644 images/tree_aggregation.png

diff --git a/images/tree_aggregation.png b/images/tree_aggregation.png
new file mode 100644
index 0000000000000000000000000000000000000000..c13b516f25c160c6fbb0746efe9c33e54ec9122e
GIT binary patch
literal 104285
zcmeFZcRber_dm`RG9oLRkXc6AWL!oeg*42J5VBYHUTGjRWha!Gy+;aBX7-GXLb5l%
z^VIA0s#m=~@7wSD{r>yuc9Y9>J)e)~<8jV;oO3_-a~@Z)s<J#GJ`Fww1_q&`f}9!#
z1`as}1}X^`2i~#Yh{3|Zz|S(1l~q-gm1R`5v%Y0!VT^&H5F8bA_-aHysrSNudXRrK
zv6%lzY6*s#%u&XwL0m;|)tk6j#1;9azUI>Bu%fUvpL3K_pnH7p-qa?Kym=$+99ol-
zAmyfulnrjhcB|V$rKri?_U>|9e5_krl_(iT)74_t$M`L%Ft#T0fUVN5XNEVwl#-ya
zPKRNNpl{jp`M)0<!|-m}*>G|hB}j^0O!#s!%WHp6?_5Yr%NPa*_6fSS4`ZoJ?l>Ll
zbjciK7*~(o?0wft-um6q{{?d@+W&Z)%{ZOPdz&4uXB`ESpOP7HPhonqzv@qs!%!%{
z8=vr2QEog;oTQl8W)tQA$Z0G*y7=Dx)8Uj<%#t$xCgc3$`=soP)@LSI&-Bm9;k9KO
zU;m!4bHw1J+v<K9{l0dm+S_H(6%tm~V0YO^j{@g3y_!#Y;Sr1<@|%ini(gHgWO-%%
zM%<oH{N{9Q%i2oJ`%8pJ9#3Oc3oDVbM;w!Et2~mM=R%Q<ANBbHvCHY{SZ=MRQ_8_%
zeG$%FiaSH8-!oiV$K`Qa?ayC$yzd(t^oEBt=)%`&Joh2WC0C`Mgy_YX)g{gFvRK7W
z)!{`2l<?7Gf;0RntVOmi3AzN5B&1#jX%#Fnrv){}+mu!x_3`JwX0hjgbg1mKutt8+
zJBykz7aYu50xXmm?%|$Vd|V&Sr9uqGh!}qR^FECyKiwvgI>Q;!DrZF<+DdBko}we0
zD=Q20aan=A{J7=*+zo%z4eY_R3Jj5IbkglQiatzq0To7nE%wvuQ+9DDF-+~p@1E1N
zFOHqXI^C4(b0i66oP_D%{mH`kPAy(3)3I$I#?*1DJd_QZRN)YF7-5g^CC20AzBlxb
zb6`)7;b!2l*K)RFwfeP;(Uf9;^JVysd&Jw|JLyI5b$uFNMmo7bjxfGdyf4yhVaMKh
z>oD?iVBiPbOcLQBAw}Ob<u1fN>3=UtEd%w^$1|{1IwqM`m2w4x#=jv+xSgE}J3{|t
z7SU||)agUFUhmn6RMIK?cYV?kIXZ$FQycZ&wv?p$$f&Q|80H46crc2ClbrB*0N=SY
zstg&7SGi7NvdU!3A4|G-IV!{TD#6P`jz<N(Y2-cR3_HjL=q>Nvk=af;(N5<e<|^TO
zww(ONLo2zGXA8-PJIH2osrb$l8v5G4$vfTgSni?_+wm(8MDK~-FT3}p?ug-t;VTWA
z9t`u))wd1$5wFbi244l`5%yiTpuB^7Hn{#%q%E6>i4Jkd!<ILb6GUSn6Fi^FZR<;q
zI&)UCjo>dl41G)R{psS{4XvGX?!ul}QkTM5XGrMqq_KDm1P$1e@3qU6%2KgiB%8d8
zBWH3`<V<X7u!c+)yDqCFTXj@;cxSX-82+PiCCkW@kHk0~Z`@Y>dO|V5=;9J1_laP|
zvkHw0*{O$9ON{t56X(u{u$qKBg_$?0H>tckp32#ItCPztX9edA-<R`WtiGu8VNpv^
zr@hCI)rq|s+r{T()L@L4zm?CBZ_&S+Z=64Ev~9#b$zd05Cv9hDH#m8F(yHlU^Tg-X
z$*Rv~OD;?DpL3gzUREWizjru5wqNE&iq7*RS6*E`bn^a_i`=ORNq5xP$v+>nAZI>i
zN8U`%!*QftRltMhe)NSw#k1#TpL?iXRW~}hL|($#bL!41WzH8T%QzP!@gr#>T_Ytq
zyP~QhuS7bX66Tb;ES*V}>7QYgNq4>MC11{kYmRD@859`_Y91Llnbes9FS9S7O}V3O
zsdhtlSpG(aCwlkZRw>S<`b#G?4RagLJv?*iUfO*&J^S1#)(?~p*kTb07kHCPy4VXp
z7P=R`(K@CTuhlhxGe9!%w1~DaafaBDN(@iT&2hki%|XyHW+taQyUQa(zTI$!^~-$k
zZ2Qwr;r7tZ(U+sCQn!<gYWbQ3Gx(h?6oecEFA8S~R9gEB-lTd?MbB4meuQ?AhMhWw
zdi0FXrMZh6Y(W>xDGVq?xk$NQ>U=c0z-RpAR%}l!(UXq%sP{ro1!JrDdIduTM=eJT
z_PSs9Fn6akk3V`|`8;v*RtrUo@b!l4beVja+dW3+*0Y2?A9`{vFIqSY1zB!cauzFD
zlnfO2d%h|tA?xoReAqub(Aa;xaKTWOy6(aJgIOY~!%jhjMAP(=VgsVL#1iawy54={
zeEXuu%;8nt&5`k!Z)IBtS}msWr!gtZmEu}Lc@E`h<yiDy=ryqtv(hPfW_9A?iCcWj
zBFj+~0ToTVS=*68&l<%-ud76+hno19q{mdM`>Vg`y<%;-Ah#g4fOlLwQBX3wno7@W
zbhz4s%aJ1JTK$vn1?$?=z28)pjxO`AdQs@pG2)wQqIegz^G)7OpsUc*`d5f?Z(`5m
zxsqBC$1&_E;R>;cq;h?B$uOQ7Xb(Akp|3e_AaDKCw@+v5kDsGDfA_=yvoUkbxgI&?
zb1vtPog<WcDxZ75`q(ql`cSiww{OokFg%Rc`C8;K+WE=2xMeA3l}A`3p<t&0KkC?v
zQ#@Ibn(uU7#E8f!kEzqH$I`#aF;ZzL7(d#eVk0iHEy`PFHB>cpCV@Zqu5kERoNDCh
zCo^%S?6zF*1Yd}l#VyqFPSz-|UE)zmxPW&-G<u0!@MIAaVIoD$9c4yd1(L$tPK~I7
zmrAD0?<t8=&!#OXB@%Dm54nY=ZsC8z|3bmuLED03Pg(r&Wcan{Ri?9i+YTW*A&k>&
zw<o#>uZMnio!%?NsR}Gev&`-pxMY5~_e}4#te~F8T<gK40w(MF@8=UAc0axQR845N
zy#J<s$CQ(HN^#-m7t@ySX}4OZE6Ux!xL@`hy`G*uIr^+-+H17zgX^G=r5-^kwlD!V
z{(S-|>uHOcO~1*btWxfSkMf?`rw_N*SL9V-Rk%7;e9PepKh?}lGf-fpGNHRQ;#;+_
zmObS3tS_z9UCOq`c^|EaR$Rs$K2$;E&U5MHJf}Ucxk$zxo58vlvO}`NLBmA7F_|%x
z(Oz4R_6@xPRL&Vb_cUH4nR}FVqAim-Q_S<`&Q<%Xlct|KcpI@AabC)14w}!I-@e^_
z+o`9{alHK1L`%r1#3z@OvXR2-6rUbdXVN(GME6Dep|+~@9hIW^TX8v3&zz>lG@JW<
z&u7>=PRLzR>q6UKwC@$IvA5(_<~H#<vpw18lD%w9NzOA@sZjaYX>suRkWxhU>z>7y
z;FzF+>%|h~q#l!=ZVGPG*Y-1eb6xZ*I_u_29fmizHfckITZfH?EXs|YG8c>I=L>2E
z_FRj*atanhcH^fih@7;`DV%Q1-I=d;Z(ANI+RoZ8aYeb6yPj~}-i}@+T(RGlKb|V-
zynA}~)5^1lp=Uw~5}G7AJzuUBE(t#yrNNoQ;W^?;G~!9IHrGLHGBdeAUE{^j>Za_e
zE1n{%#(!JT)$_gE+_(GBc?0$E^^`-W_nFok>(m2tTX(*!P0t6<1b^yH=^Y)h@XFj-
z>pT0@$ugoYLS;0)Dly^YM$%65)`<zj#`Fx86J7m@wuwsBR32uVU-wrROA4(={Vhn`
zijSe0@Yz`~zE4qMe5S(SP|%as5$nCuhA*%#r5|1EHC|Tjc6|;b!y22>^hD=yDW+;r
zhU9A&IX@C2r$c!~MRL>Iqy4%b=efRO>es|3vj?_C`*}6#9N&*A-xu|b%@7((oT$Ob
z{D33*xS8+^z}I`m8j80rUBWmCuW>Q3FljKb;T0zQNMh3d^ZGm{2gad;_fZ%aL1q|$
zcn_{ohTq7)F!(|4`SJTucp%1M_=^;NoRd(0UyVbabm;Hbs3iCdL;8xWq9XjhVrXY<
zY-Mk1?QqDySry*Evr*8r$H1UqMSd_9)mXm6_`POVH5@c9T@*94w&XD|vc74|<7{bz
zjDsQWECw$vjU5aaoh>b_?8TfVm=CTHgV)I0yv&RTmpGV9Fl$^=Wt6qHGiDUxIn8sL
zSrVU-kx|^v=$4q8-1)z5hrcA4O&uI;#CUm~oSb-^_<5}DOnA?Tii+}{=Hun#<Ay7^
z?Om)K44k>G>`(j{<nM9hjO`8W%xoOYtgRT4aSd)-J32@(Gb0cB=iiTc8atc)e3F&@
zU(138@*<z`p5Zyo`_I^Lt2pwmn5vnxv4y6bnI*^!o*^kD%qM<u{U4wFeBv*6YW%$O
zjG&;<uebj4(eJljvp2SrwYG$3I!ON1*IzgP`r%(Uit{2%|3wr(<b3ch2wD<focAB4
zN#cL!x=RLnq%)IKxeC9*%8-AUh%IpZ_>H`NwD-Cxmlgv9jiD$febpIrZWwRqqT~Ml
zVrcx_cD1~kVt%wjv;_(4aPi0Z!h2Wq{V%Yd^E8Vh<s6VJZVu-#QZy!H+K!$qW^38s
zirbc)mg4Vy9~WCT^+eQuYSlx0$bM~kSF$Z?n{Q!x*OOo8BBzWr1|}9U`hWP(7uSeU
z6*r}x=YPJ0_%s$S`G)lWGy*cTHYN&No0;gpU4p{)#Q7g*L5!}w?v1XCzI*7uT;h%P
zN&GJ>A<jF-sG7$*j`3es!l*iC@;?aT;K3Hyxa1bWBLD3Y5C!#rTj&3Z;vW_MuPFXk
z6n}1&|Fw$$wTk~2tMFkV5%Jh6bl;vY;WKPFqFLoyG&fkHvNqQr!IG^~d5eNqSLfcb
zQ*7#b9z}&#!&*;-t$83eUaSmMHT)wq*gVAW@ik{)B}9Vc4ndrR+x7FI4BWic8!2=W
zt{?ZMEgUP+--gO2-?1k~R(ot;2%!_D)6+Y77XyXM=>6+|-^dtMZAST@pM&?kS(7A4
ztg2S8_rEd>D&lrqn^UW}W67yqoE6D)Lo46t-OYK!I%?E(Ykb6wiaXS8mi_t0DOF1E
zQzR(Ul;cl2&h`ijF9!cQ`j3abk@H3~vArL{f-rcus&?f|*Yhjs%64Bra!yQH4ir9W
zWN^DkBV<9f-E7k+fXAhoFL(YS4Xd8}Vt`}3Vg#EaJTTjl;ve(-M;bmW6pX40)&@DD
z@XR;T`mJ%Io%zN}6Rj>wpC7eJZeM&NXigFI#HPg*pG&t=W1!gblza%?8J=yBN)x@)
z5XlE^8}5Hb`zJ;-CSmx<plR+Pf(qu$GpNUTaV0&3PRdi~LL>*%@^o9w$!jlJZW(4c
zp7fF0+mL-CWO;J1*ph!rt$l=`J5yc7k&gC1OxBcum_trGa+V2(wWY|o{48*02v5wG
zS5K&M(;&5LUf61gqv&>bI2pUL!en!l@$S}YIOml#hjQAObALwmy;JC<S``$ibBx*N
zT?9MrGMi}xn{pfnXvXpKtm(b<+88}g&iTO-VWFzswZYB;6P31Mt`q-K{(*WfQ!=XF
z72~9ogNKZ>tAfTgU)>DQ@mTF%YT>PUlgm6L%7zjv>|UB|napqDA)7Bk{|9K+c?EPV
z;aDaFGa{DtfmtYi>3sh1tmooe%AUd5Gg+vTd#`GT%Ive>75C=cIHj&*d+vdG?ff5t
zVvGgY7XHPo>pB*(O;Ih#Db;$kx?u=UK9nIUOS7Q7yh=d%^Z48QYNa*?o3pt!Ml<cn
zd`3;g8h;Fh;o|_-tstz$^8hiB>q%gBDfS#gHuZ%0rX4ALBXJdPFC|^eyw2ygX3^0W
z%Wu+<%`imuk0Jam^&wt#(%7EKMFJ8uqaqff?&YZu5#NR@S~eCZB2v2r3e<CT`EI?Z
z>ewWY=GMl+{e6?+GKN{9u<*Z}ZwVklWBBypf6UUnay?s%)$j1pXp;mNwqoIFD_b%u
zQM**}y^RUGFVAC|r#?KLxPH_MnfY%!7W8Ga&z}|mqq3j`Z+{E}o8yo63>UX9h|R59
zdm_Fy^GvPU-KD?WF|#aI<v$qsSD4IY_DNqD8SM_@9-m-Xs37HdvyErt_50=F@}O9k
z1VL^v!Wb~&(jCmhrVKtZ7*s-k7!&#<0MQiXW^81Y8@R+AZyF^=oLE)wu9J=J{k9BT
zmQdJcOXB8Q_b^aA$eK0}5w(k>0x(Wnoc~+$f2-6d1KB+Bkp#?Ozl$Vbu%T|13m1}z
z7uaie;bH$$nF0eQD&VtAPa!!bmJSc7Zs{;xk_#3-rhea_()^e8pFk%OA76JKjY2bx
zsCaMxzP>PVklVZEEHh3NZmA9c|H-2w=w)1TRBayhzh;0;C<UHO?5M_rxZF303?;uU
zR-f{bsZ7LJm;d*K(TpyL%};A~se#RxfopF$ZsR>g!hz*&!2i4Yapi8nU|&;ph~bfU
z5gED<O?arI0-U8VzaftBS8G8pff88S3eui~pRj{$Cq`-v<HHG6T#Wi#zbl&fZaED0
zQL&5>#vncpGTbO_+|I$mU-U!`9sg~8KA%Ae3JE5clt|FElOPrzuUgC}@=3%Pfgk=g
z17t$Pjxbn8gq<`zl2H;aUbGEezkx?SzKc~V_3sH|px%KJ!o=I2L^FGPw}3h6?0Fv&
z2t_kt9C`Y?qS1{1_lErDq^jv?b(Q<(WK8r_oTz=O%korD`LIl`Zk5sd$7gyB3QXFf
zDY&&XX1V;?L6ZrT^1qvdH~KTI<<X!m8?0fB!$$)fpa0hTFd@qU4a<drqRfkNA{|;s
zi*5FHTsU<~^XNqF-iTa`S)U(dr{=$P<POcYFDM7A&VcfF5#Y*Q0~NoF(>a2uI1!zN
z3Lv25QFwLp?dP#Nzw?Inlg-9lCT$7B#ft+^lZ{)Vdu$<CM0~0b(uUcBvm&mhHu=>I
z4y*!ggv_?gmI9fr2r}D&@9c^0YPz1A#w}wJDw2=Rek-llI$GHNT#0gX=2>XgFs-mv
zWD8Hldo2?tcTnN?4<d(tvja>lW^l20-#;uswrV5Z8$Q*I-SyGu7otu^OG8jJ9w;>H
zDX$6OH)&Pa+u1xPRrE1iTRocR#@7Ya;s7R?Dh@>uvZ?=NH0UR=A3EPOzJqtY?XhlB
zbC_ld5^sD-Pdwrc@Sq7+dM-!`|7xL$@0#lAmO<+pZV9(F0rkxXsvtNS5oOumHW-Fa
z9+=W=wh1gS!P;2VD<blS5c=6;xRu-AD(n`j)^Xl+l#w|QVRMU(zD|}6Vlior!wfZ%
zHwBR;i`tU^dwMY2RAdv*2kKygJZ${YS%(55*i|kh%LHUGJ)jZ1%|bxI_1)a|a}x=o
z`8X-Bk-pIvSJ-pQ$afOnG=#zGWNwZ#{<#BvVF!{Emti3)!t&8Lj6ZOzO);9^sEKiV
zZ9ane+&w5g^51%}^0m8VU~j%;^g>tKC4ffENC+Pa;s0}kh$CvN6rn+;nS}=Ly16{9
z6v1|hE8@`!`DVjViCfuE2@;mMBRMY1+?gL>r9rE9g5wIiBb)QPQZP`-c*Gq3Q*SOK
zTA9EeC*jbkbiNFlW(A~p#yzKMO-r-P?s-giPqy~+n{V&+6#E=H+zj|B%aNj!4F(mG
zYW>r*w}WD2O2!os#dM$+ammS%fWGvezfD6(yVzn8pV%Rh!7$o#uvoFoZu0##$u15U
z>O5NccPEPB6NU_xHjYMy>PIc&lNUPqt^p{+*9tsBJ${VQbOCGrdD3&w-K~7*#hZq)
z`@ta~ZwI<E{6F;D2l1wl))rAj7%?&wdAjXHL%x0;s$TIBGK%rrd&dxTY^b?E4F(@m
zu~0n-+hiUL#!UD#{=dxmzz05oN0}<q1;8I7x{L`vuTvExQq6mFq93(BOIqd>UurtB
zv^AScI|z=4Cy0nX9GsF?<EyYcpus{~JM2G<1@{t|pa6S_4A?pyFL4|C)B9L{wG34z
zQJ1CEPb;4zRGRPeR&!tzP((hH52YC_cbsJ-W4mZmX_#^?49(P$K(+ciu4J?Y36ie&
zU$#d?s06e0y`Bn=hVRat#xrH(=Ez4*BQEk<g{B7Gi?HAbTI<RVShN@{y2JMK$v+mY
z557p>`V9$ufR@31b5>QO*dq30rg~d`=hn{7a$AEdsPsW_EEu@{{Qt=~s;L0Mn-*&J
z6PnGN!kG9RX4<a~_W%Et)tEop;LTl<&Rjhy-c$2YdFH)5oR?Gld+%INK@b4Fe2(vL
z4haLb25Ve9Pv-+4u=snEp#lK9T|hkY>i~ji&1dHy8rAt?_lOa60GoF=hh6<o4^#^y
z_*nM&AtOY>2-w&alhN8nQ}1J=hyC%$QngF0{txcIf(nQ~>(qSQYsa9!8(eC>Nt;!6
z0r3s6mKj$&!9T5q3s%+_C~=?)JP}q^1r7nqtI_B>?4ys^evcJlj4)TcrKAibvgt$k
z(`WzOx{HPX%{`|O|Mv*Mj!(=XviL%k9iGXEg6HG5>)7D?_!2NMU-}K1p&6yY^^ty-
zzI+KWFlB&H%1!axc;rKyI%day--OEK01C&iBr79x#)27<B$bVkqp&H(<(~ZRoX|)t
zWohzDc>))E#{-0l4?DX~#!<Rl)_L-GVZ?z48GDm16Av-V2N!0<jJB`i1PtSRR{(M7
zzs}kR3jsP|htCNj&h;!nsIyE?-`G`crtP0!gJ=EAP(&`nih@-F#E=}11Xsst*fHPX
ziyF0vP0|rsAuiujHW!%jE0>y2ExjRAX_}1D<C*QvRe8gvYVz-g!W<NcL6TT5s#nS2
zk32HduC#{$OJw(U7ra_ZZ71f4Olp*{w$|oPf$4<@64Ew<9p30X`2;c0f6wYSF-o|u
zoc8q>bNt$rZ`{IMib`imK^NTmU<7PI=PN_`SU%$m%tAh5e}bKVOStx_bv5TviIp%w
zOP53F&$7Wz&OaNli^pU0ZAf%NbRV1|-_19;hBMEwtVz57aMqZI!NZDdd{RYBm66T|
z;<v)PaMp)cZneg7W@{DUPdkKMLi@bEPpRaGL-^o{bzh$J%d0QKy|a^=e_J59Xb!NB
z;HA_Ic33>IuXi9Wg5DY)(zaB(EX#=a$&zX&$p#TEZB8dD4VODU#495!<Niqho2oIf
z;*dmd$3%`0bPdr2$<PGNdjvufPaF6;%=U19wiiA93afhS>nXFr;_S;`AegpX5+07!
zAWSO$b5b_QCR%UGIE_q7C+X5tA%ysO7bjY9F;Vh{R<Q;34%Ql5Ty4s^`>AGKX?AOK
zny&0DLtW2a|2`H=4g`;J$+NdZK)V~q+RMmqcfVxaie*)zpqBEiboe&ZzwpZ9qBv&!
zaoHd-G5e_p<Xjr6(Y$&*$4*{V_>T;df(Y1`znjrjB;C!U>?^f>hUCR|Gwn<hV|%;X
zElJXTpTm`SUP;BCpyRaJS}~(WveVs_uJgM~pWmGTKpJVDQ`Yck^|{*b(`6i!gnhCu
zaYf4?=1YYF&vq<6RkI$OdrQa-0QLjCr@1wIu7<Sx6Yf3$U#aWrAk9C(wgE~2Cq~_u
zA70JY>fR(w3jA|y8W_7*`~nT)qf;qF?#w+F|6Y5D4>+HzXO&`jxVPkk&e_R!j8L(w
zBnY?~n5sMg<gL)~fSN4d456+Nw+RNT*1g}OZ5;(sof`A<%Xo`lH~n9R(Fxm`iQcwM
z02DYz?sM$a^(Jr3Lq;Q&F3K-RS8=Z-8Po?ZK^P;bQhMz_Ve`ixzKg{Cj~r#h$o=j<
zC*(t#3eCEV<_C)Mtw$wAZN|LeW~tWP(o2NG)*}`dW#T!nu$9?-@&#OVW`=s;l&srn
zQx%-$&@zUVH&pZQ!E(qs)#MIXLLJ+HLi1i_d~y!rXBGCee>@vqTLVtei?a9tT(g9E
zw-TNKhQh2TEA~uDEksV9YA**KJp1sk=u2JbaUgd1_pZKBduuMLSMBbjY<L#t{BP&R
z7)A~Tt+@Euj0IVbl~3bwFP-xtbes=q1j7MkU|D3XHMQ&4@msX7a%&f3i8l^iPLac_
zk(Nbpo9qU{Fa684LUzs#`|WF^(gfm&KNHW4*3=w1E;;mAZ!GAzCvHUtK#xnu1Wac@
z(2Em|e!40_7x6!4N(Ws|`F(CMRV#4RHZ2jU^e}NWDZvqHKDh*sHO&{-GNZZls>NTD
zo^|@RLMt@a_o{wPa<V06eK0fGd2zgW+U^gR3Cj}zD@&Ik`HF;VM&jaHP!umXqVTWX
znJw^BFDVsHRyggu@Llm%F3$WSan|RyL@E8;zz5X)IA^0g{t%uwdI$o|`1!Vn2OvF#
z^)xugFTJ^mVCdHXFjHo?oOh>>kEqk@%k$dz95jCtA^kK_EH0dfl0&t2P3J!qDSzeM
zywMl25DM61YvmC@@^@*Mp5C-;Q?Nodw4sctmx15#Dj3dGiMlKx*Lh{*KN4?P<}vUI
z8K><?5Iy-g<5w;=&@O$iKdJ;guQ4Pbi&+=s)+L?3>C`5Dn(25Zog2%oE%fZLUw=eh
z9HW*Lq@~AJbng6-&0(NEL2&ke_V(3*R6@v|*N2@ZtGB;Jkg{HA0ve58vr*yH^Z7H=
zx7t;fRXFN`aky^Pj*0rKy-<73oJ};1MALr>6x0jRez89N3%u>Ejm38HG2?KBQ;bXi
z{<}KA!^53fN%JCrf{*cR5G6Zot$azEo_ZJ2__cd%uz*P^noGLP7>N}B9+o8+cI%R)
zn-=0^OV5u@gi1xX#-F|KdD(NW?@Vvusm?%);qq?l+`uZg^#R>{yUAuxH$ie9oxcC5
z9VeJ#>Go!)7zmS*6H9V`$No!uvft;XN3zQCVo~IlA*qjojvgoK%lrhPTblQUkMDGz
z;#9t}|D^+Z)g}iG$=zh4*WQ_v8b!CSxh#JWj@Q<_9r%wd#+<=M8>N_ku=@J!r#-eD
z%2s={S+AsBOd+GY@|vvubY0xjI;Ra5LMGp1^vv&$P`U@HbTXVEKTz-n{>*6C)V^@f
zi!1U#TT+bT+d3g19Bfk`e}r3~X_TKlu-B`9lk10MYXmy<eMsps>Dk`t^(EDx>^~O2
z)34X3ns$-8;!6Jk14YaVhQuLlNBz%mn6gj?KaOPI7(V`#kEOh-1<X3%m<AEKq{<$@
z+^LRc_Z0HO*<G3IPa->i_!M}IC0YT~qd^w^`PhGNCj$VQ{&)?aekx8H(iPvOJOm=4
z8A-5!u3;gh6%u&)GJ=o)qq2MAz}oy^c3vI7X<wCFiRIgq*Ry7XEjY9aGv>?a4wN6J
z1s=W#Py6px1D)|}Dow|nG$Gv!`AWtIFstXP$udMQsJp+Di@2_2923}ByM4NGeNBAC
zzD&Q)*V7MYzWWC=j{6g9|D~)?U=04&4b%ryCn5uVMgaxfmC>Cb;g$+ch$xe(`xP0k
zfO{v9555U6myI`+aV%R0!+7<olcw{L1uEcxOpTnI3rYTVqjv%3%FJbzks+px7Q+K_
z{QS#nnYVOq1Pwyb#zJg3xTQf$e}8Wm>=Xp~w)iCLg~;#twC|IWb;|7ia(rVHU_~Y3
ziUa>3M-k9f9d(<J*1-lzl}3+R_43{?vKS~-gsdwvFw^!nGcJ^zdd!(k+n6Flj!Q8V
z;>GCL1*^A@_1F90Rrz(kf*F&lqS-5YYxs*kf_*tWMss`Z@0OSzmAbLN*m#^(Ht>jA
zvJAG_aCwn{X?v|m;QlW~g<5r(fx5rr4|5^w10s9Is9Fo$Bs;M6mr8|HKh5AFjvO{4
zg!6%sRQJs#T?4=VOdo?ni!Vqc1l`FoUR4dCBOv0QU;8#ZThasdkTSpmYLLHva+0Dw
zu<HZGhr{ETToNU?5tOQP;vgTqQC`@Q0K~e|>eucYT|zXZ5}5O4dA1YhYYhB0*Q}B%
zCfgE6Pnmw7>kd0(*nm!dg`mm16=<mEJsiQ+BAHKauW+*dGE!Ah#I1q7P`zzMefCb4
z5tOL<4Ca0&hYHM~RTkGifn#vHO{RB9fnJuznP)C7F}yKaMYqd}UKE~+$8u1{@iM3f
zHpO@3au9BZO&!1f=@<eC{eQXJSH$1vl9TGo<0U-?%CnVq^?;Zt`}#5yff`F)DpKz{
zp2=tLmbd5JI2$YG__9~%`cH%ZZSgk1S)Hk=-2D`E{4>xIPL~Ev72L6j=*2z@o3@vU
z&D{&sxmBtkNVH`})Mo4?xs4!YQ(R}|<~f%t1P}xsJ<bC;M7~g>l$UOT`;sEH;O)qw
zOO%p(8-|;`HG7jq50Cxh6?{HJil@*zt(=J{Lme+p#8$>`y4AAK43g>2jLRp~i$WVj
zRK}oe)X=WD=PF2d_70b6fa3-U2w>Xuv|kXABsdZ=@yG@!MI}g(zqbd}#|11!dfAh&
z_Cuw%ozLWtn!7<DF#<O7h=);d-alUdSBGy#yaE3HL9mzOkfVp8%IJ_%+ft_z@4G81
z62`+f0X%k=JDQtI^i!^g&QP*xRc}tw0+iCsk7(Z$!JiwcI(scQaMWx6MzQs%m3Ag%
zR$KGkNqSS45r3zE<?hA-?oMv1H6EsNDz{P%EZKy9y+i)EV!CoX&||--1F55lCZ5ec
zkKrSL3qY{r@kbko*bUc!5%s2id&QB<joY95vfQNF<zo=zjB0fWfvm)H&4pA4d8h>K
zN{b9aXb~&a3ahq{>fP?iqMora-=@@aXDS)>tSA~uyF?o+=}}(Pij)t3hy!g0&Xr}_
zKD`@mO!f}ML&9k=8M~G`G$(P4mxl?OUx)0;>p}1dN0cHyDwrkDarSym6%A}H^T7wr
zQKz=&yH%kgH)t;kn`nr43^-fsbl9AMA5G~8F74M`^IGpXV5gkF>nlv#A(;5bqrKh0
ziw|vEm{Fr}<uq&c9w(Img~I3HAJY<bDrSau48qwX0PN?Tk15O6YNCDw&AOd%Ue$;9
z$vMXX(E#0yihq3vc2KgnNm6@~^r6kY?FCsYW5_6t+Y%&t7HK$4^L{B?D(L!@V&g*&
zQ}}T;MveX%e@AmTtCC#f{2Dh>P!o4q+OQ%rzrjv*qs-3ur9F66Hf(%yg(8W*K*&gG
z_iftG#2=*-VHDF$)s-E-Psz)(I@=p+in@}W*ux*0BKv5@hR{`|!H4MF1H(8ro1G2Y
z38k-4%};$v<0Er2ywsv8QK|;1)XzwC7Mb^!e)M_DOnk}*CPXFe*ZN`X?3uzq;<|gD
zWu_1YJfB3!rLV5X=&u_eM`}s6{HpD`(G!iKN6VOd^}MQPYFyr@*q=l)CY{NHSa=Y^
z8S${kNjZ?J!>rO`vE^VhctX;U8jV*s^WiYk)l~){lErtv*S{zZD)<Cka`a&aXU1;M
zzv>>T1K%p7M;T~N>w7PzS#juX0TxGcR!*eHV5S`}ITAs_kjBw8C%*{ku+?^y>9-m#
zSKM5hyfSZc2&GKgmuKKtc)R-oJbJ1`3k%;<^JeucD7&6F-5POQcqg$wM7F$bFN+n&
zoK(-UNkHSE!CIkK?qCK+)f~xb=yVc%OKma=uxEj;uj^XB$t3XqL}h6=${k4JAM|rU
z>HQhPuuPpy{M(c;P>LMHF=*-0xKkQ=NpI(i(Vqfot-{XTr_h|gZ}h2w)_P@--Uaq;
z1Lb~Q&Su@=<4q?*#YycJFh|W-zYS~adaPa>{qUlvi<HAzcP>g@_Yw3?xLVz$#+1jM
zVR_LewO<K5&ihPBB-+J^IW`Xfc4E)<vd})8Qu-ar<t<P~F}v|7IEWkHT)GB#xX3)F
z5)hdkup!!mn&1oe@#7>t#PoA<=y|v_I+)&yyYV~o%*I3kBD2ZyHaQv~?T7QuzD<JC
z&bX*?6e!}X38*b|Z&_pf<fze0_-|NMZQPDx@7i{L3V@~rk`9&VkSi}IqP9-mkst>*
zbLztr!DXkHGoK%beGVfcNU`SpHdxZOU|aqQRKN6^fEQ~h_iV~Bj+vsHivd|9LB8k=
z6jIYhSnLhofn~bgvR+*U8oDQ}6jC)<_-S{>+VGE^q^eTTb(<GFah1@W#SQp7b$v(*
z09(u~@ZUiQ|Lc8Y)B>itOfc0qdWe<Q-tb#jz291vRG<E25~N4&$`woF{!fDNjuTN<
zV`&d>(TDM32K<2>Fy|W#t}{#p!3G{*V+=wiw=zcU9d_2B7`{E6zI<Yas_E;jCb0Q8
zEBmvouenjgD@g}&b$*hD&WD+@7LC1?E|urN^t>p3O6z_I+rv+>rhS=P%q(?eR%(AU
zbWy%BMGvso&T6loZqV9nuL^{#Z%9NMXSM0Q;q-iKAqDI_rT)<u?eAMcm73$=#dz;Q
z`^P;Z={$>mKFu1>Dw11Y-A@6FmN(yFR9r`xxOFa#XjvwgU0D3mz!*8^ZoJHX#gedp
zXPN!9@AWHg&s=eiB(zAY7(vD%cMYUc3f&l!1#OZ9n_IwrMA4tUL)AFl^r(IYGaisc
zSlcvGzc|>z7?|sLh^Ebt20-bDYQkwYG`RZ1GB9iMD`d|m!g+3#e_SZ5bLE(!Tsm?7
zL0)T@F3}e2vpw0`9MfD}`den8(w^j~lh?w5d(xb(CaCuDT?;YoObuQz!0h#CH0nO&
z`0eogIcaIe5tLX>BP89XS7mF+yGl0Sdw&pCz5A99e`~aOPuPlreklXWLk&Yjdu%qs
zp<SYvp?r1<!P>%QYgc3=fhD7=$}EgIhK-5Usa|`8#=Sle)PP-On|3kw0VU&m@4B6j
zG0f0HLU{mL&>JYIEv)gh>*6Gn6A}Xdcyh}wEP88o)@}7V?j#M}LE3!~9}q4nKtTM;
zsA6o9{A;K<7~HtbZqXCQ6gR$o&Um8Xp)u4IdstD}_%xj}v|R~?j6r7`UU)Jk>8ajU
zK^4r<Ufg1fs0r^uOV7U4yL0=oL3E6+>pSx}XZy2>xNo$Q+}6MG8N9|a^mU{+?^{;l
z8QoU~qF_$2+Q#+cwb62~@nH5WrK9v>S4Ui?={w%3%W@)&tE9)4zn$r82K)J<-e$0D
zt~T-I2S*shMGOX|-;yXeVD9cVLMCtALNS>3#pY20reB#(j*jS$=(t1RjDzp`1|m+X
zZk6la(Y3yp5ocxz(6>57+g8>|e%a}EkT;}$+T6y$7b7WHyLkG3NWmT?<WDo1JX}K}
za%yJuJU1toAl7M5<KUA!<WB*x&~E%P*o1_(9@!i1USJ!cw>k{;9Kub!ShIb6b*~)q
zPfu`dE_dgueq3bLfI>-Qd2W0<jKD<}>ygSAA$BrJW10Y%E+|&qnNPj-;Yqlt{Vkwz
zbE~&bcGKPkiAQ+tZ;vLVm*3XhZ~bVHh(kp8_%^epx?p4jV^|UjHc-?<T45~%zv+CU
zAgZjHyoUpRbw{YgV;rd{U~O0wp!NNo<xt1kc&8CgsGAn|>~e!Qy--+^KYd?H%*YHF
zr5*ZKp?~&)4-2V{LsHVj_AGDh*7YZ3`>$qbIZU1O+bka)aZA<1{mMJ5<-ijF!eC8B
z*R2yW$NL$q%yby+bF{^YUa=~hq?i?tcfRgN>cvXq<6F(-xVze`9n;H;<w%Q-$xbjg
zRMurK^IGGG%V*l^SV?F}JL4+<xix-p$jJTnQO4cZ=>4Zc_gil)1Hg6uU|{&ozCK;l
z77A>VX8uuDrev0AMolb-2Y0-xXjT@qE0EqBV7(T{-yYB`icDcZlXRfl3J~^mX|ABn
z)ha)F)d@GAb{-n63X6x`mp?3lM}p%0PfCI%*Lwnm9Ur+4Jo_VH9-RqC?LP?iQbpYV
zO1qLkCf2yz;SzXQ>nI`l%6)f2)O*s_JbB<*qk!Xil1?KVJM*+Sc}2Bd@4Gfs>*6z8
z2A(nvrC8&BC6>RPC0nWE`sMi&Al~h&ivlQYkEeYFEsm+HYueI6%wfu?Y6<f3Gn@rN
z*@lfFd{FgE%Kn%@0Axf#2)OsK8DeECF0r8dL?peC;kc}Js}J|d4fvxw@n#lS6C|j`
zV?1gYSKoGw8jHK}IrH$p$jYUdwW9b=$zkf|xWT+z5@pgc`oXbJo^a!RxP;rC4$3Nr
z47Hy|kAVuoBX`h<AGE5tM8Ty&yz+vaLlwPZxdTDquy_t6fFvHV3^TrmaE^olB9-j6
z^78Rrpj`(nQa&?;pG;mA<k_D-nfBC*ubQgslcEfa#%DaLx71akZ6|;Va2oYc|5mXe
zc|V93#f?uv$2As-mS(^9@!c`MD8OPgvcj>Arm7jsJTozetWE)w8419x$?vG-j9}u!
z!2v~xd}B4Jt%}eZUBbgebhsBHnPda6O8Zd@%`C){V-2w((6?<2DsvsTQ(EiN?1{fD
zkcsJxBV2?>c~V4%N}R~$l}Wr`SA25pE?U~{_zbOSLd5Fi``E6>Qu@#X_#z?FlO(Oq
zZ~Ezc!r`|NP+e!7rz)HlgkF-j>fng!R(NivpQ|ygSs!tGxY#O-N4^pVg@Jd__UO>T
z!KxG;Su*0<Vvc*lUQa;s8I<c?CZqDLhQ%_)#FAg`iK`OZ<a?6^igz+9vl|mVA99_|
z<^u|8R@LLao~%+y6aY6Gy+GJUvPiE)@l*!`7BTMSvG!zH-6|RZhxP=*r$UzbRle0+
zHv<W_%=Q-Nq;I>C5TR=g5a&*0pBf>szA!pk9KB`z1VZQqsOngRPX0XS0J~a&I*om5
zvgy$Y$}4ww_Z0E)c+%d}j$KQSJhQ`_Rw*&z=-ymfN_j;FH+SNFR3y4?whz6I@95T?
zCp-1LO7cDh_gBZ`_9lsv9+kxl0C0wmeYb~B7~N?)N%uYxq31!qy=##r)`xTrp}M8p
z_+(xw)^B|LF3Aa=mu><r-RgStj#5=#8IwR}Ql52~8FTb(j!8&PXtl+CbB)nB%Q`o4
zI8v0nvr3Y)zRqQs-&mm_Y$0}Ovb?v9Q;*Hx-HMt1F`v%Uj@HO`pUGYfe1shSCQBF}
z=lt79N?{()z0GOLE3N^$b3NIEZwHFZ_1-@f&g~t2G_|0TkjTkfp!0FmO)c<Ag^2U_
zvHP4=#<1cQyTv!bWM^JVlt?q$`9z9-$x5_ccJhuCjpj)^VtLzgeaEGDGIC^$@`G2X
zoTo|aPfp$D8Cu7cBh@{2&WQob<Ng|CvukHDml1wRv*4Dlb-`@k9&gQ#UGqZa$hlmS
zW^L0E6KvhCV9DL853|-yC#vo(RAN|HZ>Ax|6d&ubd=sdv_q;L9)-H*Lb|tDtbKU?j
zvo<mHpk-X4p@;=ynV#T%?RLe)B9oxCxOTi4Bo}j2XqpA@;XrqNo^L)kb;nQ6;V~6`
z$~iZd8FA`_b8f6NpW6^_Z|FTADun#5QPZ=obd?qrsa<kAx0P&-HoSAI3u5sWeOxuW
zYfpPs&rjX)N(68~y6g6qOROV>NN=n-rT)yt1o3{VXz8GaXNbQ{#y4$KYuluLuS>Y)
zcK-&_t~?4a?+9aKrW4F8Om3YGP=1iJ&yxYw!$tPVx18zf@moJB<u{6qJU+gjWjcBK
z(z$H2QVs5nb1Pzu#&1W(F$c1T*R`srpZB^Zp`{nnCmwx`3DJ_FUQ?*(oK1bNCAsrm
z7Mfh|zjAMrSZ{(}(1*sm$9He4HsT$<F1h)c%#g1L`kt`PzVAz4@6P)S>4$*tJ(~ui
zH9~R=Yl<<9cy<|f)en#(d!Oig;9Y>lOuf`JI;vNvWlZFDi(&b1{voGX&uf=8d2jut
zY_Ln9N6C=g{WAh#j%Q-HW>~_ZqvJGN^gcutogdZTMRJ7sKBMAi(x=ZexSJ5wxm;)6
zp5*h2NL2P0iVXlJ>19~COmq9$7uC33CEr(D>?^|g3h!Qw<$Ei3ade<N0e_LB4i&(j
z;4HK9(4!#rh#QN~$ciHM_&f6vjChsT?pLHfD#m`;ew-*qSr4s5Y@GGPu}@{TKH4C`
zm#J!#?jfXNwMYjrtMT3Nu&<5MxFXVw;SBg<@(-$4DQ_<lk^?i6>JUq?s+Qul@4R-$
z^kc@OGe<8qQ7VKTa@56h>?$LNLPj)WQ5w|s!!l4?%y+4I9!JQ|mhZ)ztDjWQnFBr-
zI;@6Y%>BE<Jbn^Vi#n&K6CO$<_A*oY%v<NmlyxmAJhb&j2SVlXC^)h-UdgC6OcuR7
zX3=-TV^(8SvL~D`*V}#TOL~vXCn6W4_>GzXK)6)abAYq27AlL)UEp9f9>Jv+ve0Ok
z1$X*bxLubGda3Zm;v!tQ08DDv;z^K;`^ld@x|@;-MVKA~F<X!3zIQ$4+7w7u(@|p%
z(U^(T{$lBK%|d9UBfW@r8-F6p7Ax&nW<`lJ8^%B2C%xY)#O~kIW`p{IHIY*OGqnW)
z=%Ye#$r(I13}8oIY;u6mOtLGZqJ%Wo?SG;OCFN3W--_hb8=+}X3?koxAh&b90BR!n
zmV-iuqX_>4?cgOLO6E!WH)gyDYWB7=Nw{W+IcWGy7w)3Zxjk@h9UXIvvrZzmAPR^K
zCN^FescO)66JuC}VD{)X19nw)^|dT(N_Op7guu5N66t>upEv(7HOM!lZ5Z;Mu)(aV
zxRv`}1siLs?M&ki8KtWC)~<Gnn!XR`BY8n0@MP9%bFM2rw4?sQzBU|iNYH+A?kpsd
ztSCwzozuQJ{5q%WfkjWMa`KCcRCLVtt`oLs0)Uuzr9bGOvImkC$X!D=?LwIR-?000
z;1{gw1U>&oa|Y}RbX~!;kI=VTpF`t=Q8(Dlz=!2@+}S<+>6Kw)B^@*UQqwH6^!1O*
zZa5EUg<H*En=eNKkkG|BLZzSM>am4`zxCW0^jaB$SDcdU8{)E8e^knuK25JOn&a|o
z^QVLA4jIufRC!fwj+q{d1bOFx^Qb6!VdEp^e1;2)@mUf>HTJS)L1ZBvikX7WX0Z9(
zfdEj>Aaz9YIvLXT7#?>&oEyT^z4&)X;!9fea&bH`gZ|xfB&S_V;v<vy$$Ljoqo%M&
zxcozkb*0<hGsT)FJ!qmTJNqF~Ogev!{5$s@pVz=oRaSp@o6Roy47tF1`GZ#bBr;O-
z#q}N=*TeV;Q5{S&g+yZgnVJqfhdpSu*(p}I%>X#MieYsD?&Qr>&n@N|g(k7oExQ{*
zQcW?uiHrR7Un$>EP!QOX*g!t8un>W!LdZkY1@;1WK+kqije44yvq=Yl&=mJ2Q}$Zz
zK}|N8C#i<rWzFcjj-=z)tL;;hP(g#LC{o7xLDT+JBbpIY9=a=)n=FJ<;OL0%GTR2x
zZgRc9oc)f4hpb*r>Jlu?mmzmq_OW%$7yrft>AT-}q5d#KyQx*!Dz;W)5^S85wBAje
z3JraBQ}3xWY3hTH#=sw%vr{qvYpZ&o@-SIEXvNQas=vVGs7ub_*;FjucEtwAeA{>(
zoza{$5xrVGAK#i9m7RBHj2W^gzNpgP>PS$vqGOhI(>(%7-``D*{W_8d6gB?L0(342
zKCV&6F<*Heqx<!so@AQW)%R}$y?X)`Kyu>z-4IHK+l#x*gX=A4*s<}&$`%QDEA<5}
zp(c|;_RUPQ()raHfgqk)+OK;JZG^0<?ReRa&PNG(RzisqyMX_$vXDEM7|<G|PccuD
zQct}}F*;5BElhrDRiF|;Q&8D$_uFS3i0&D20MXAs71GW`aA&UX(UD8a8$w&H$w@x#
zkg>$&%y-tXd-zp>kQKXMUh^AKZ|kuC&{^qX4<{Z%An|Jh*U&+gGXF9&Cw$a%`@=QM
zXJ^3g04D@zE>;IKrR#(2r(3bBE+YM{Np((C&y&~>YEpmG6j<Tsk^Q(QE6;vK=zfS>
z_Jm)MmcvH;{?4>i&nGdX2PR)eYrL)oRm?zJ^bF;8HESdUfnLAXO?`?sg9{FPUxi1U
z>-)OljEW1KkNQxb)uzg3+{5$?@tU)AyQs@<$K<peUf=Sl@8trFP7yy_S0Z;xwSD$$
z9G;kGo+iS_=PDX~n77*g=praSinG$I^w!eyj;x#ep#UhizLP)h5t(yoIX+U;I?e0w
z7dn;!vSz&whRZY>^irNf164-vNMESuCKP>33xLL08VQdTrPJ}BBM<iE826Z{QFvKa
zqFDO%JUEiWwitJ0z+O}DUh>a$4WzY%3tY{2ctTB9ucD7EXSKnbW9m9g(Berr`7z@-
z*@dJe;cUPlrjT|dSZ~i#zS|1OkA}*SvQ_2cdBgr?FPSgNNqRJ{%7IzKeb5jx=MtM2
z?Ga>e)}Q~pm-x!m+Z1XJqo%OB%B;mQ_f0#bv7uK;I0rfo&bzLDH5Q!DsrVLtRC1$M
z%cL$ArHn^@Ro<=GQ~}7h*mL{39eGRrCW(T=)QO?uOLr^R2F!H_hYC|H-Bvo}pF@yH
ziKxDEz&pv1wKEjns!j6ADzn(zqnSGiiNp%@N<hi5PT3F`=%1@*$?yg{x2eY12U6l;
zu-~Nx;E>TPguBj>s)w-cQ&bB=fUS=P_|i=ituWepRA9uC15$&CXNIY6(O`Y|h<3>p
z7YR9B*S}d_qMLWAGR4NPj!>VKC@k^aDzBPxKZdZp-52AfWMui-lnNE-%Ak2un%#MQ
zt~=E$)HEZ{q>aIl*-=lVBnWRnceQ<AMfEV@dCr45nvsdPtz~sgC>_FSOOo!DaI4v@
zXkm@f8Sl=lv&Ur}P3GB+Z~I9yAO*NISP%B|Scpsz-TJO8R%pyh-F#0v^TE^J%hfZG
zhU4!V>$OQ>;V3;0jqdQBZl_#xm4Rh3sHZE_Pdq8lI#;6#asIO0GO>==?rH;V+kRDe
z6L`;4K*I^DXScy3orY|K+=0{XaV(N=1c;O6Si&>2v97M`V*GOI(&N*0rv#K7F=)qm
z#%MX-7!qOAf6eyTUR#2eL7dfgUWbOz<Gfp=v4bsc3svl57vt9U21=|G2cIf!BL$~Y
z{22o7TPiqhc}$UL_33v@bVBcRcyueBbq3#j_*wRZz^hw(#>Y1VGsn>9u-mEO5+`3z
z>P)?!#!P>xm+Y=&b1f^`?b>-F<)^1J<to$c?JoE`QJ~tb)6X>i{w{!c;xZ(|h-u&Y
zQu<AJ*dd~K4Sh<C_Z;*vKftIHXY14W+<{9DEsAV_^9x<hPF!KX?(y|SdS!8$t?~D<
zx}_oew&%CCl9<xe=$isdk=|5QZzw(8^L&(pnPT1XF1Ti6oWQV8aMZ&}M|fXKW_qS0
zLH|b!Lmz=@8+My_oxP@;IM%7H^%82HnT4c;DjMW8*4)*#pD-Ub=mRXMhitU^=@-K>
zyO#|yH=$`sKv*+z%IIlNU}OL+BG_}2CYMw>>9oU)s>@WYiQ2VmqwNDw`FlA(6$l<l
zD6~7+01Av2Ia-O(!;-kzW0fR|r<^FsjU4;{PLQhpxdwY07nYm0<PiE(-z&og?fR{$
zJfh81y}fLmvd-l@=aW*Gr9L-DwU}4Xs=K=lIu~Ca{kBX;Hfn#o1$Tq2o!6!?J!a1%
z#Vh7(%xSS0G+&g8<fh!W%4OwuvHa;!AZ3nyqO6TnUHysMM;CWiZ=aqfC-{gPZ{EVM
z^Zf`d(hxQyQ2cBACRz+v<fLl*+9b5VI4kMakarsRrl}-axxbhfZLMUWyw7xgMY8UK
zh|g=_U(d0Jt#R*eug6g8I@dWB6fr0#C9!|Wy9@^!@><t*+IcCvuU14%x5Ttj8S2!y
zf5f}78+G`&d;8<Q?or9%DOwIJF`l@2G5412k`bC#PCS=6=x)gt71$9R`>UR^HTV`b
z9WLW(00?FC#e*#7Jy}cZqh5za?)^AAq)aB_FcStj+^vNX{nhT##@*H13dO1tk4X^g
z{-^sP4XuO1roZ>PfYO&}J7pOU>&fH3k~*jkJpycYp_1K!fL*m+NCybg2B~QA!DrTA
z-CA?U%2Z+&%BC3%ckJ!mII8#@aGB^YaBxrl<vJN>Si#B83~nTPZoPm;b>10?;ruK0
zPk=``rEgy-9NbzUEsf#Rj_ts=rEOLARz!OGangZ5WGSu%09@&dGe4|Pl$<J|=NC2C
zUvPL13bOqizqm|B;#g$fqfDVA9_u&CzLn2@UK_NIfkXq#GMFLLdj4#(KX98iDHBsq
z&mF><FC)(KAC#@DjK0I^HTSAfu123A9S&=}#x;lb0An{TAhh7T303`dC_wUZ28!}s
z7E~>uo!A9H8;$g5iU+^}z&w(Tsi)S+5vPXBV#-d@T$&cG`of4ON2lP=+*i0&3Wb{;
zsP7hEIth&<FLepU9+1{w8tAnB3D+=Cq%j9a4EWqPZ0^^9D@)PiGDq4^&%EydcH`mV
zj^j3=@R0uQyZEyuj=GhU4jMG}aaQpht^8cy)rEHthZMJQIez{42-<WWXL?H2KpSlb
zZ}f+hDt?}-6*c?rwJQL0&1c##yY54)B$b!@=-18?S0JHp9}zZo>)5AHs=DAH>2Gu2
z^If`Lq`5U#ygP4yGc1%LydaP(VLzVbDcSrvMjaoBsjW}^b@#2N2tV3ji!y-8D7gDT
z9znA#ut7k(GRjzY0h%~>*KW7x`Gko*ru)UN!Vx+^h7S{tpSoj<0VgC#T@)xz^WC)9
zeSURZ6DekvHS+<BO|k(k5)Zy>9_`rAamb<ii_J^(Zl#~17I-W{E8`-a_OnH-Qv8=9
zB`!+<bnd8$-=g_q<n#9tEVI76<Qbz6;MeY6L_?(^K~HOKVU+jWJ@Vi=nK<Ow2xHh)
z)WEaeBa|y$_Wf4M47>X@^L0=vc7XDCcyn08KXtXAM=QUoLUT`$B-P6(8&u8C(tW{&
zCIIBr1ZO`bFdjqB;>5Aqe0q(YYlC!cCfL+nfZFIT4k3-?XE;*a_u`jE736RZ7Ji7Q
z_*EWiXk-lk#M#xLft#gWqMTE?bYbGUSk^fx{TkY8e>><S3iC%nVdc^>p&6SC$w$;R
zk-DydEHs9MtA?}vbWSWthir<(nXj{AFwtHKH5zhupAS!k?}ylCpR4)UQG)&v%5mSQ
zjlr?;^X+4z7U5;?Uq8M`x`vq9;{J`jK-FgGUTe4S|K;R4It%7_ll6lK_!&6&fE-Hn
z=gjlizLTl`8radS5qtyP!1^DdP=OM2cb^kdPiT#6gSLmkkp*C0R%wOExwSt2yS0z;
z3CN)1<7X{gIb>K&nsml7d3|UwP|G(`G;D)3EEP_!dxqRRXvxArwUR=om??B<Ot&Q-
z)#?Y7wMj@b^PDpBA=0t(*WNNCh8~zh4C&0ogiz@+<**~fk|Sae=K#&0;eeBJ$hrCe
zsH-87-JjyL8{dqo=TyEYgO~${X$7B2s|7Y;wJZlTwDQiB&HW?<(TtBlwx{XWn1~O-
zxKxbx_fv_HZt2H*;apmU3Rb0`0#i+eA0FJHAn5}>UmFuhBcx`fePsSaI+NdKI*=F*
zc0kx!wEe={VuEbp%VZc^K^V547(*k1C^3>L09H2(O<-Gfmf9Nj7CsF8u|VQ`wa^zc
z56wfmgpHxckGcjU=bD)Otoy=XlmFG*_QR|HJOvws94T3;Q_c1#6LI<$XY?-oZN~av
zhcxkeaZdg?#*23S(F4|(XFshxsC_*{weFO~X=ush)gAhm-fUu^6}lpUJzEhClE88|
zz1sf@h1eog$(oRFBLHU>lFfeXM_X1cCu+dH&c2VOZ4!DRaI$atps>NOw{0GPihnh@
zvZR5CZ%PW^o`*IrY)XlXPe`3G>BEtOSjbs}7R!=hiuEnkzd{zNraly8p<YfWV#8=!
z0B6=2Z}H;TZ?M4LBli87{)d%<V1u{kGRl-d(mG3wW`QTLmZm<O+TU#R`i!)tdhO2Y
zg=COL{g7L&B?_?C(qN_m)M$z?bsL0>%i{2xwi`tK5_npnuhC|YKPB+5qt<CIU)a7w
z`ROjvTYVs^6TMQQUfYlwaa8=fH*!SN;c3}E^e0^^DYr5Bs}4upvH3te=wj!)qz|i5
z8Nz0526h>YTg*V<hj}9Ftfhv@w>lGjWDbV5p74!NT`K|vkzAT;&=_av1`Y0M3XLK3
zmZ1}W*8voc`@p8t{^V=Y{vD<<Fp>v}#tT<L)3!jULG~xKVE)`H{~WGjv;alsy%WL2
zR7%pT@k9=qm=BN26kGH^FbK=P_2H|v@ZeuqfiVOHh;0R*M!X&;o|03eBbjLTLwAya
zEJQ)y_-4tUMMhkhFth)J09FbsY;JDFoQMY~z$T9XEMi-hw?0p@KdJinps%ost%koI
z6M9_F4xCzBF;mnj^)+xAzjp)w(+c|LukXNk^A?5l%fo?Q9E(rsiJrILXA^(NIQXs!
zBpl1&LFq!{pm3%KhX72q?*XeWYzo}9TKjU}PY?H94-C$el=yA|SYX_7j1m=RAE4(|
zzE!R3*37pn(m9eg0g<~o+;;x21=@tx!b4Fwgzyy@cmt~RG?#-eK%0VEg1C!sLW}a>
zV)*&>3-ZV&TzaMY0*iEGd!gnz+6M(++416P(Kn#H-68tDC@%Q>v{bl~K5&Je^?`6q
zvtI_jEo8v@pdt82z59pIY@Wg{98BPtSN!|vNuLi2j{QUeTuXb|4_wW2_|}MD1|?SY
zf$G3EA&mnSs~7Jn=a)bx4dT-5tXechb3dI<zI+2|VG^($`2QGt6KE>e@NJykRvV{m
zLm86H6j2gFY|30n17(OrnncJPTNH(4hz4UyDnp|oqESjhg+e5SNGc&2{@1fP=lgx@
z`>*wVYn^k}UUl|<-}iZ+=YH<{y07bc-t=tXear2&;=gC0Vs_BuG^orW!Y{P2&remP
zfTVQ>JDcAs>*I2DA7lSp8VqSlOVPm*2m{{Tsv157azHLpPf&*LtZ5nuH4^h*=MXaC
z)7w&1@Q<j5<<IU{2YtD~Oq$L^nO7i*T^AG2EkQqv7qQFzLPTf*121?NXrql^?hTZh
z>5O*F+L!vDd{bP61*(ADTyP9lB6G?O0IE=i_tFBgs%p_}uLjpKW*IWIRr&;ZfB1>E
z;J=Fv5jP86+x%#TF&3G`3Qs!aE(L4^l@D)L@_<)V3WnFy|3LvW_GO<tf9Mr-P%#!>
zf6yQ03iyuDWUF`dJKYq!^)JmL0CP8;tL7CP2#6itO3)dIAZO+{c%5J$upCS1B+jKc
zipF9Knl)!$<m%|q!xOs514E_W{b#B0cq^eAJFp)W)@G57C4n2<es~NykV(an2};_<
zwTyWps?SoKB|7x_|I6bWu#v{i);2f5z+i8+>=L1kTX*c38cW9XH5fpu?hkpk<A0qC
z(Pe|E6)-7oAAf`*Q8NE8j9i?CY_348^|+~H-M@37G99x`cm7=o`dYI4?etP;;;uQj
z%4~a)`!Y0T67j#6+%H!pCJN+US`{)LiJV;{TqBX_eP90G#{_Kyf~iosu?zno-Kv=&
zM8AQNc<g;4lHrZmob~D1mWP6bTu#)iS@wg!K?ND-pEMBld%CZnTz2f#Zgqi07LfEj
zv;wWSUi}~J(%+A{*3X{4Duh)(yG;IoXB#8Pe`Mmf^*dDY{cZP}PWxQ4k_1_M`4OYi
zFX#4kow0T2O}(y(rCT?XH!w5_HDu-TWTR;rW#mM?0Pz<hXb|Z=Nv)6ka;IeL7&p<E
zAdeM4wPrYlWOWk<pDmhx!^RXQM&cQO#Lqx7<3T8t(>vMrZe42GcDc)qf@UO+)*AjR
zpA^N5>Igl~m>+KohH6QAh@$Njz~+Th&l-xpX`6vCl8rY8PRoK<FFEgB&y2GDV6GK1
zSq5^&rpfVN76sjz3FbTy<%k6jZ7le9{om*CqbO{>9tUz!)Nt#Ycr9OdQWHh%UNTEw
zFmZ9s>{P3Op&p4z*+Y%(pNZ`b;;fpE&uZ&@JM-MbZ~8nTHmsM(9D0QdN9(?Sw2q}!
zf$4x%dBE>0?a3^|5WKrk8k3^SL3_Ln_g>2*ZsHySx>q%Ntuc*Xlj|YqICI{;)Z{Dl
zIMS4;_8MeUFHpCBMvHjWF~_<Ey+OS1TZkOaWPEl5W%}jqRAdP*e${Fj1j_f&j}krt
zsf6nf7WGYa_t7K4B&9F<YNY$y;^v6mo9aBD<`*z7Apgd+#|-&OPuNHOyXpTQ8=J&G
z?7_BEDB8{tzUl5>%hjaQajo5k`>31~PcV?981UuTQf)sH9X7~M()$CiXiU%28w*la
zdtD~HcVIs9O%8#1D}414Wp>)f6b=-j7bG?6;q~fhA!A(h`WjEtks_r5kVQSjAD8QY
zS0`@xceZC@wugIMIL5e5X1h$a&p2lf)n|<73tn|K*oo0agX4>;?mp&E0g?<K)enBx
ztOC!uedh?SWdSr;T{NYP9cn~FF*;QTpzAsOtz-xqe}pfP->?Hw-!QV!tzMF#8*a)L
zsmD+JHzvg9C05E>Pkbj<aAdDWy&<Ejxk>%q9kTf}z@*~*%H~uz!dqM!kYQKsp+{I9
z{@tm*e0iL21X&B4nZo6EikiBc(JfJDk-Apm-Er;{y|W_gUwSu7E#fonwkd`f*9BzB
z6{RbSrejRy1me&@$kW?(AMs&c2!nHbIjVD;gFAa4m!n5wUU$awfEN2Ag<?=CpE|ua
z%Y+K>a8BX0Lkcr{zL2{6g`USxw;%cYO`Wi+;u{}+n@d=SMDgMF1xU1Xs;1AOz=S<B
zSn3M$pqwk!^~4J?+>Q%}*D2MN2l}3c=#<Df$>O<q&$r9^(|S2>VkP1C=ulr{UPHDC
z|5+{H{Df;}ZPV*H@>(SUoFOSrMv=Ghk>1lgDy`aW94OA^kQuHF<M<Zyud62WHVGeX
zaSGybvKU>}AD%ZClW1TJqp;{TAPU?hMntG&63$b-jjw^(E4<--iC0eI(k;(7yu7$<
zdV;Jo=s++gc3479S-$$4jTeQSCVI|aE^Y=z2iukK*(WG9SA2S2nv)cCj6ds0KKU>q
z73)6>T(M=Kg~UUw_YBIHY~&a#3TCNC=T%~g$UupBhzL(1oLH5(cK^NyGY{%<w-OXt
zxuY;o0zFA+jYg`y?OwrUOd==yP#*Ys252(uyJ<IPdKzRym2dps$l_6|B%)ZN+{d(l
zo^>^v5?+WBs4ip%_6RNGTv~TOIPecxyk{@0zQU))+IHi&Wgw;bi8xR_Lsm0)J(0cl
z-k(;j!~ODLrkh;7``TtYAT&TXBe7<4i7ds5=-rr4G9@@$0nq*=bmv(-+Tx&BxEgnR
zSax!!=vjfhvMw<9--NQ#wxhH!KLJrs<X~=J%h$v%y5Hb~IiG=|#n0%N<1g0V=9_*T
zZ<5v+*(t>^i10a6-gCVMg<#8*H{QV0Kv*ZpPb25hehPQA*qZH7zexdBz69i2mT9a1
zcBbfE%tZ2Urv}flniWYp_sz?{!l<JQ4C^y93dhv#8@{qohfu~tqOGsFn3d&@Vf5%r
zh}m)PYh#{*?!-_6$%%#*Taw#F<0i&o31J-}jgv9DxJPFCwL8)54!?7`x#zX)(*~YL
zHFJ;OAMHG;;#kS%Q0npMQTANcREk9r?D5z+gRdIeskj;o-Qf4;8F4!K<`qksVXxEa
zzge|eWDyofSvn(Vzyd~1z5{TMf>hH1sql!7?e;S>t_6Ho&OvxRRG4M61uC?ihnBEj
zk2TWS;-5F(tDX2ChOIO+yfQ_ld4}R+B>Pa`Fs#4_8H5Ecb4bT`dkpz~I<ZCS+3Kzt
z&v>xGBH=D;<I>QBLW$FYsVRL2e`}>X>Agprsb5;CIhh5NBxK!YR$}pQiR@Xr23dMX
z$ucq`q5Dv0*!^|eW0OV3^?8Eng#cW%_SOm44V(g5xz%^3GZJD_@HA&{yDWtxPzsqB
zdG+F=SganmH5M?v32HFsjdX=HZgrCFKk)`3#9(QMyMMkc1z&|B)jiy-i}E9YUl<g)
zvepWJEB*VEMe<XA`E2fMpOj5AI!2Aw5z8)iY9~>yb<d&awD8M6=1gm0K}yBM<Mz&}
zGsk33;90Y@b06o*L5{9{&8;z!A#v`U9XGkP${38Gd(hS41Co}7>YX@Xh5X<{#5S7I
zNoQW;Ik<Cg#)h9}rK>GRiESJ7I5(jod3Qhf9`JB8NJ!)eA6g;5STZ*qgK4FEL}Xe`
z7#3<fD*`ETH56QXCSr$BCKCKEul+O_Ac~}fK&2Rw(RF_<gd`*D_wbS@W&~lFJNsU>
z@zPN#(Xy6xJY_gxuONaTq7IpL$OX;?giPW8F+y<K@W-of9<*>e+upM#K7AQ`5m?2d
zLr?}_=W;bm1Y6M`AndNnP<E4%Kt5*Jw^MWG%-|enFg7-JqS1^YTsQ0BxqfSJ+l)Fu
z$SkhLsXN}i4I~hlAQG?DshT^7Prmr$k_J{Hh%&`vQ^p`P7|&m-w~MM-*Jl~HK=)wy
zJ)+RUypA818AA^?9$<}V6{*UG>n(5W!pIt*ky~`{aOo1uI<Ywi(L`KYhQ(_J1{|T(
zJ=Hxi1&Zh9s`aUwTd)Tt@4aWMjy3SRx`E}I%yi={ma!zs>t<-`<}KFgH~0nDClTe%
zEZ+)<kU#lmLmpp!N_Voy#|~k77itDH4a-0X_>yBbU0`<-4<{a<fvC{qNVw<BKDm+C
z!z^Ptj1FLF5aSXrv3540NI}+3+!LJ+G;vHEKQuDXhF86;aTvwU3p5=PT+19O9DVh-
zrZKV59qdI^uDK$raY%k_54;KOfRPRT+oj%unSl1`&NX-fV(TvOJK)s^uMyjH#c#w1
zhaL&2N58DAM42*$VyVMO;yuNk25QEGRZVtMz@LizARdqe)N!XVSP)`7DS(Y5=XPhJ
zNBp$K|9(}eXDZ`Cj75?ft8=t&Q{`OdLqyJOU~mgg*2WYb{<b~W=0?_?m+cSDl*^?p
z*8EPqW7eJ4(4I={F>y1L|NG6nm_%*hT2CAnAtE*<h7jcUAT`M*eJM-hFO%p@8KbbP
z+0t|b^JKWbVL5sEOnDqYgBG*xUTAAnJUS}l!XfTja&2qg&Dggk0z;p<iv%%$b)DX`
z$O!a(SaLQey>zL><1dI|v*A|gLP`Yc8voylDXM$o;Ty49df~T*0{g!&iTBWpwLEKf
z<(Cd8OfUE8Auz!Z=+Ee=&OF0jWY99-l<<JH!QpPq)U<dDYOGt{Js&3HL7v5#!>n&T
zCUMo_XR9D{3I+1uMfw4Dbt;$Uj<DUU{RT4xmTrFLwW;zm`hlA@5BIx$3+Xy-R2HCR
zqh)s&LGR`qQ!iHV$Wo$TV-S!e9yoyQ?+VD#^FCWH0L4K9ROdVM@~keM5K!2<esZi&
zxdi|DjATT8I0*!(K8?O`HtzcsQgeltS1LHtJhnePC~IjvYGgd^)GZ1-s*b`r`aba%
zxY0jp{sBcATbU1$zKa74C_3lW9z1gCoZ`Fpy}O<8>_4$Iw+DJtzK~W+-x!ZW`Q1t9
z?Ny_}V8P^l>R)hwa%|t8`m6|_W}tIQBzw9u(8%$>g%aYo2C-5yF@?K&*F2>axyHUW
z_m8OTPNNaN{Ww_XL|(fquMeJ88lIiuoAd47?F%fNzsTI`c#^8w&7n?d%jM}BGkt`0
z#8OZ*){cW2NnoqXpB}SOZg2?@`6ZCtqP@JeLiYo#5Nuo!DI5QYh$k+yZQOp!TTkxb
z5mXO(uM<8menI7Gl-fOm;Z%^XLzJ&o(tG**b<I|!uY@qLt?$7C<b;xtzZK4_cM|_C
z6YZ9W)|0T8)!C+ozOTRA91wIT!>5y3#&z7x&SkX|^g)EDL3XEAFUilMk#W$wLR}$f
z#@G`0TRLdWXArixRrTnW0v<n@XH=TeRE~VPOxEQCqE(OIBX?!&C?OAT^RTwQJn~DZ
zXxzrroNImJP-w0W8Z9KP)VrLT1rNZ{+P`Q7mLApU%#&a1_$z6wQBh<NV3Bjdh$MY_
zYgn_Ym85`Y<V>{qu&+rtElzb-5WB|EW5+|u0Pwx5xHaEy38|Xyh`H$<7jH-pzO_DO
zxgPAZT=NZwU^8NJvFQ=YkGx-?42x?9S*Zy84`H_WGIE=@V@Yz_ofcSobpY6zGC1c&
z__>eB@%VrF3eT0C2k{`HDYv(uam(+K>wyC$MoM<Yj*F(S0T_evdfi7|8L|3LZv%^<
z!1P0^@OW)%pkxQ)Z3pwg&dtOXF9^tO){gh*4XQpbS`%=)L}c(5BFIfR);fnExP1my
z8w~s5(5jYiM6$l(b|v<QytTlc4zAyB1GVP9^XCQe`o_KYEM)DOs^nLDv@IbxxP7&4
zroy;0aL@^xHIZxYvj%tz+ToJM0BLTbgCY93)c4@+)VD8;zl6-<MZ)Fj-o_0+R5eMe
zBYM~$nZzyBNRj@6p{KA7Jll&4E0hG`Wa2HK?f4m*uO!@-?eX!y?Nev4;cV;ss6;@J
zp0kA@s~2qA{qmd)X!t|#zkHcb;ZWDLf6wwjpwDI6%;wtO4p8qI>|kTAg0ZXzlKt-S
ze1R*=-e1%UR7;V`t9X$zRlB?(C!J`5-A+Xym<PBY{;k3cyS7+4W;&}piW?NIE0Lk3
zQNAdTq1a0VQW`L@Q<xb^-ML5}ZhK}>06V|^jkM(q^ce59kJ$T-|EO|-nM0%N#PP$}
zar1tAEI2&Sx<peov^Jq*8~W=?SkXUPyT)A5*wWo8!m?hDGbE;dKw8v~iKtwg_<F6t
z6u9Zjx0};h_v=<Kc1DCj{3qXfX72X`71afi-r+dG&Gre&7NjaUNLYIOcywtGD{1y5
zg(J6?x<SVjlDhE_?lW0Z^ghN%q)Deq@Aqm@vXXrl7RGICb|)4r+Z#RSddu&{wZv9$
zjdb>J*x^Rq^+EOPP?huhfKI_lnK~|}K4p#KRaRn67bG_;XMQ0L+qCV0Jo|fh$Dyxl
zEbS(QL!u07l$}r~`{1s;<F^J;Bbi{Dl$+N}Eb(!BzDp5asiSZ9unbHY0Z3c2bCjA4
z#b>ZtX+`qm+gC4oXnb6yA<IjG2vxsdplPy`CP~bvp^%}MB>)?@_kC1sg>%5qTCMLk
zIX#afL}Ur#`~J*&Zv6hx?L7*ti7QPk9dE~?lc0V~NTu(ZvXx(Lo}>GBkWHJkH<OYW
z<xXqsqMtdnW?OQtWa|H1s`(i*H4>7w#x&s$=51d>P8(}bdjbB(Ioz}pWYQ7K^us#~
z<A~K^Pn=QOlx6D7uDK-@ZRw?@uM|lXL)n>fO(J9xef&dE!`N2!wS;KaY{c@oexMo~
zTHJn%3&X5TI$VK%ilKL0_4oM1jB9b+<}J!wucxfyd3&eHK|#Sff4$Fo`GwxbGIQxQ
za0EQ{jHC+rvY(M~Tj?AYVHG5CvB<Q0BVSzNr5PZC3CP598i|WRPG>A{nGw2W!?%d#
zyK6=F*$duosW5*ZgbLa@5Fuq<pyE2Kpg_5rv^BP{K;W&uWal+++C}_NNPjA4>xL~Y
zQ_AjEm*u@&^<7V`H<4H>En#ZGYjQNLC&?m8Ma@#8-tMu~=^^?PXQi|Hr!$Qu&YB3D
zR{M|KnVKqZzx67(b)@7~@hhG7-+u~6-tYT%C%^Artn>F@wtd^_p=?xfx)ddfF7PG^
zh;Vhj{k`=CVG)6Lx7|)VM_e+0<JXgUyk>0M#EXi8Fb?kL=n33>AKv{{O5V@i*po&f
zKft%1O;6&%EXD|(VcD^get`9B$88UmZy`kd*QvK}s}lTliMY+=hBWPMBw)L^pkr~U
zYLRdApX(P0cJU!{oBA?s(0jJJkL<Fia#+k$FxO+l&ocx#rA;mCws4Z%a83Q&Ii*|=
zOqounW5w2dO}XOq_C^1dkFi4~&rAsmcKvy^m(MTv^Xf^s92cvSU}L8-#L;IF*hxL(
zDnVb$PK~fM*{Hmk62&Lroy34jX8+2nXkn?+{tu?5Ma<gD*NJi#V)e-mZ3iW;^#THm
zS3l_R_byBpn)Qzbui&tt3s`y7c?z?h`sO<EjbRUwgOe6-(Sf%Ue6aaB@CB(oj~C@B
zAn=+X5|d#gc)0EQh5haK?cW$Fq$-!iZ%JEfM2*-iyk|TdgAYF+UWR3);GQvNr9Vwv
z{=%Gpk{`*&$?NIORe~W(`SuQE(}_r38iv+dE0Bu)t_7hu_3(6jly39Q1WGcTM|eS)
z*YEypUZZDe{PuL!K^g;tM@wR4Q914uAmhIYV&dz~ZOTq)1$_B~-l~B$pUoa(%zpQP
zt-|?B7xROzfM*%}3f!nm7U?>Nb+(YF_38StkoB}X4e*Y)?%E?rk>F!k(s%{l>dVF%
z>wSb}NHU0-@9#p$^ZLT+5y0&yk2K~%U%qss)*}<<t?w*?na-bG8XNq-is8l1m8&K9
z7RvaCCT(TON_W41XdC_t<t@0~=Tfd|`6T6BHh!e>HT$G`d(i8FwGo_Cb*6{)PNa&<
zXE%p_Qo^9I(;i=73)8RRea%i)kqym=Td~;mmbv)purMwf*&|~b1vTai6MFz8q^k<7
zbFB=(5OHm){u<@}waoRU$X~U#R?Csi#=pZe;=ZP{jUQ*diW+iDb#XBfT=V(ndS;tg
z&m%aB_nn8J5Y_AxS!%V`Fh0u+BT=foXD(}8#6vSGce7DA$vt$i4?2!S2?z*uBjhe4
zHu)x7liT`SYv8FKv0<#FJ1qf@`Zcv)e2XYFuKJJ03asVVVNb!A60hc4)+KSBBjq+h
ztRX->>p!s%s!pq0t{b#onRsJztUE51#~M5~sv>@30cR}nBcw)9nIj%WQ40h<9Qk{o
z_uZ|W4K~*DS0WuRVa=R18_UzK>cP^CoM*J1Ngk8^JD>6GjKZByxK`GjHYi4BGR#$r
z4Eh=2J7yKeiu`oL%pERAO6A#~>nNDr%o(PCVy?!3KI^^JaEi-67G1H3A?}QO5dM{^
z+DGMECVxTO--_sn-wZ<QO8ou8&O`)k+;JCKf{S(2eN>aXyEpx&>Pc)d604YAnplVn
z1m4u*TQ9JVQfhb2^~shvC24|(_S*mOde{^2M<n+&@Q+B!`|T9+q_9TZZXKK61B0W?
zCAlVe5v!`!oN<ubZfV(Gioj2BzwR$+wPa%p?akl)IqdGWZ??HG@*&1<3g>TP;Uz8#
z5S@P8bk1TuOCe3~D?m9PJ9(lJ{u$B)-hz&GmL86GR?@iCxXj5^!-#K`2+g3+k5;8H
z2l4dbuVS^1@_QW3AkuT<-1evvNPpxpt>*yCKLu>XS06-4$Wyx?Zegv%&`^WQxnW`E
zVe;E<W{(ExyinW&n?iK_s%no1hGoz%h=%EVDA`4@UJfmsOfb7ct#g?2Br@<BpSwYB
zv@Us<eM1E-QCsqXr4onxZ$ZU!xKj21d8PMR2}<5SBa&D`D41I%&HWphK^I;0|8N;g
zXVO+Zt9IbrfhH0Q&;UBD)0%+9>p2W-4zxSK$o4GS7^xO-`4Pny`HvrCEgehFVgu0R
z1t$}fV8kzSm0P&cdDE8;Ke|Ae*T<!-CCd=E!-V-5|4E0oE()tRk<k#np>kPR*a5nn
zCmCSD8gB|~xJ}mMkM;Sa)|<ZO6^K97yj*1Z)nlW1@Z{*xJ-K@1)jwUG<{&BmIN@&K
zn7*aQD;q~n)@6zl*uuiJs$?3sO2|JxxBS~$)~vmXu{6HJTeYJJA3WOPq|5baTqe5V
zPOEX@1#0eLtfvr=#5&eL`mK9uSlHr!%vsYEZy&3i&H)cnrZHKB`lkYq;zwwPPyRO1
z1<G`v`q5Z-eVV+k=p8pd#AL)>mpa}yy}GyJncWu&_nX2-g=@*mH=bSsdJ^te?BDW+
zg<U%~%b7L9DkHE<*=fjoF6Y#fm>1VOJ=LvFV3bVfs@ImD#v?5>k|{Z$Z)rU6gS#n!
z8sSmxxtR65*>HX(+euD3jmuoDYi7otMwpIF6dzeDu8-^TQo4q{aft>AlPGT7#)=vZ
zPS!p1lEA>`z}J2vBku9h<Gs`OY>Kbsi!O*Z1yszHtNQ-OkNJ8MIv3g+xx>O*45@+B
z_YB}mpjA!s$BjAUFMByy@5t&n?)hu<s<hHX+_Tvn*{GL$TZ?a8w=1!Njz=8bvh{p{
zVZGZVmP6d{kK`g70NhP*(yq6f+E1?*hAI6DltKI9EP8C-qNTucHk*z{CrF~ht(qR?
z)9?~;oiRO8u#JS{E+nbXzR@FbLH%rMiEbPNNg#1_B4=y(0}7aRvN|xa5*F<wYtPa>
z19n{PMTgD>GqW;?LRuZfGZcu4{L;q>R!149#MbQUd>nP?#j>JjM57>L{z+!$e?Nu`
z?xZDOmY|b?x0K%~r$8n24u8meveA^dTo{)Wn0vmAN*dK%#;7(<WBZUTkg}P_8ghCh
zFB5&6YBYTftiAGWZb%xI*IjR+*(hupsF*s!5^lSS4bQ~+_*gtu!(8FnfiW1*CPUR9
zlQx+LPr%s*9qn7YfY$vmbkeKgM7Cl?;0}TS0o2p}GEvVybHndwHm{6VAL@!jePae%
zN&HKW{+E(Wu>ZG!mF)Q8H&S?GK!3NIDQ{<HJe?+uDQ_IEP3<JfU2Wy2jC*LtnxdP$
z-oi&Y0&KcVp-s8pI*E=IJx5t;s%P#>WfRu)LCDnL1ec0Ij%CqFw;-f=eEINJ@$S_W
z<+8!Bq3`WG8X6k9NIe9DF#lR3QP%Rqu6`a*TNd?tF%{K=Je5si;d}}@%V)slF@r~_
z3z{Yy_aqp$nstEWc?RF#rgVRF=P#GDTb2wgQcyg~TEvg}>ULj*-h$yR(~W$#D~wyo
z_`2SZ*h)&p)Z{&KWDWsNL<aVvRkxz=<guA&&c((ekz}}Vhdnly2T70OhYa@w*|d3B
zz9v-_nu#Xg`R7sP3PH=rg<NFY=$lOz)u`l;T6fLFH#SP=)YRq4^xP@m_%ahmpwWaw
zf3`N)Z&%)zq02>n95WLDJ;{jC8<*v1R2dAj0Jor&G+|Geq2zNx3(<A-B3Q#_@E?@g
zpVZQ3$k_eiZNZKmYVabhy*&<$T*h~x)qN%Z^g3jt<VzCMO8=kLaxa4~Lya$o`FtoT
zScrc$yM08~wT-GV=r@V^cb$H=@Dj)L8e^lb$I=d>6YV06i&Kn^$G1RN1#CbDSn~(O
zAp0|JwK)~zi^9<bsoiC3VthtwS7))#c{B4$jp|<7E4y)p1e*S?e$TK|Jh?2jJw}TO
z#=Z%ua6!6AMDqL${v|@b3w!9(8B>P~uIM0UA7ln@E|<xQ^(OnWPtYJVx_Cj$*PP^R
z<R~BT24wSeg(jzHJ(t5Y&mY3je2IWs{W)kQ>|*~uguXN(YLq}U<MQa(+%JoW6DZNe
zDwXzR(QPx%wZI<e92)yAPO;uQU*b1y%6soJA5MSYIDlMVH(VpGA4@tunA&!53N=p6
zyKQ6fTQV5z&_-31^q&`W9XVy65dp<WGEwJbWs2aLq_Liss|!I#H6?75q&+<%Y?QO~
zy4_OqyU;#8(D-IBPDCUJW6`gh#Hpn|zW^bS&_<n~MxRE%`rKu3u1#d&iUvl1=K1wc
z7R=-da+vuf-H|+tR73h#kIboWs8r&CpuFJG9d{JT^Bi7?lMG<xp{9OC0m8d3WD@?O
z&nvCkbS0N9TXs~WdQ<j&f(XESTx=W8vm%mO^9veInwB8DoL%9345nw&{-O`9X0FK1
z3B9HHY#uR1Ao0F7)*uCYDKDKrSRVJL0))b9uuzslisor`&l_IIzy27fCyZ|babXw2
z>CehpJfl0lh)%y-K;dNHkz9W+jG=)+eVF-l%}08j#!VuJ-d)u9LVC$+&aRi|tw}nV
zuL|0W#UV}R+nKPD%sUD|w+ol!YpWp!8=hx<QWAujXp#`w!cr)0=BJ%fxoEI@W(I=(
z!*%+{CwJO95~X&AtI}t)w>`5~zw$bXdk&9SB1}40M{g~b5u<v`giYpdzjIZ%)O6%=
zhrw#GuHISG`&CjUoKA^f&7qD;_LYw_YL8hAtHN&K4`73r8?L~p<dcVyb^g|?n@!Nw
z+AjtuazNhK+0eRi!4j*-L55d1<;)8VFY$~k<YfJzHqy5Tx7MC?uGYsrZ8PN3N?=yD
z`L-_u`#rx$@s62N$>Y{Y<+_2s{Cno^=sc5LFj2u;sW9cgX+$3sW#YJ!XW*dkJVt5g
zzJ&C+dHmwTsE~#=cZY;crh0x^L0mj>ay2WHWkr>+j7oGDW(tvvKnvcwnE5&Aj=2|V
zK+xg!`w4iu{mEY#yBDhMcRNYW!{Skt<(UphDB`vCI?!oICV3t~Y>yqjdExy{my;70
zvd=G^BRgO6dXx~FKL6t@3@*HB;|F?GF1{qAYVvd3aEQO>O>P40kT-dMX#<C6Q7tJ7
z6g~A$<yfR2PHeie@zD_{cgSupM*s8gilH03k`{RqVfI`+rLz<<BgoPkvBc#h_fj3I
z?14vog760wvRN<o?-Ub2t{5jdE9U$FqG!j48xL-FNf8UhO{&G9T7HgE|DaJYODFx+
z0zvQUDX<qreGt43RxF2fuXUs0?3tfor%5klqHS_ApCJS@HSJ$DE6<(_869-8wX2H~
z!e-;ux~bwwu$HP7qN%9Mu9>`wKB&e{<v4gs`GX7q`Uq(u>GkVH{!Jjv02;cCkN%Ko
zDF=1t*QIScQhW}lg)BuOzf8$Z+llXgJ+&GIOvD7Vuc}F20#Ao+Dm$!wwg)Qp+-d-L
zAUa}wZR^Vgg88Liml_ER{~Pbhj4-(Zolh8<7-Di&&;G~DenSR0k>uPALWM->Bdcg@
zowpsMCt}^K`}yVhCNc~mh~fX+Y{{1<2a46tO)-iVl0ae={p=}{l=lj2;GWmvb`3<q
zyTx@lv+aLg8%g(rg`Xk?O~_)4n#1$j-l*f;zWmd8Wp+dDZ_(P6x_c0vjl0F99cL7X
zPN`QUH)hn~#DwX>lRSpIgyo&RTi)G0a2^M;n2wEnU%cuT!s6bO+^~1@zJ2YLVQJ~>
zv4k^czR1hXVy98%2pd{M&B9u55Iq@AhqKp6wBTdl9@y)8`6!bJGvj+a<}shqRQJ9y
z-U?SXvI`*S8#UTgwvEMKe=*^cTXA1|j;#HnOy!!=LwdWrPyhQi;ZjWNk$pa<xDrQc
z^rD@$zNVpCaO^_%D>Ka{k92#lnw#0wIsdoT#%VC-;~|LqUsIfx_8IH?&aVq3RWnw_
zY*=@SZ6Ze-9}=f%Y~m-VgpGma7Kcgr9FCRqpPWhE(EIa<nO&XB6w@SPE<O}Ll>YbS
zipLpK$XOof3_QcZ6J4;ui!NCrqSnACsCr?SV=4MS`<cWVoB5<mBCY|?Z51%;DMm3N
z)zFe-oKoeaK6-KS<iQ`ZmKP1@zAN*;rTw@67BLj6x)j)!QpYDabY-F7SPrBX?=w$>
zRrh_z<C$2BM~LKRpQv|`TUYky%Xy^EuZoBE_}oOnX=`T#G|=arj@rJ)8q6jc4o*t0
zIj;Fumwl9neS{y&e@e(HvkLo_Ur?y0ay}I&0!X4&ms&RXkQ>K&R1^>ArNU36Rzit5
zz&IUMvTuwtE)CGzk@jE8$PgE!!plyY94AK(7c6pb>#TRF(;0gAY<o$DQTnUyD>(_u
z*XxWS5<HZ6n#s6|(#1IG^ivC(v@(XgYmt`X2n}oV)IZYh#bFF|aXv$3ok%+66_dXU
z!dtR$4PH-nO-=1ihZ&RWN$%4AbSiU~1S#T$Rdz)l$bZ`Dj-#hiyQ!=Y(Q3pPQLNjN
z1e$9aYLqAQXMeqF-nZK16lm+-&6k{{^62p*=J8bKW)hE<O2wqpjUBKdRcjr#835IR
zOHA0f)q{hHW?D62KLHd<LeHsvzS=fJw{ge5OWQti{mnuC`>r$WzDD2E2x(ezQYBV!
z7o_pGUV5Dj-M#SfbV-{n<pC}P(1qRPSP~ouQRV&Fy*MLNDsOo__BrpA&3E^2v$cbX
zV+0AUWe5%r_DP-4r4K@5#qm96iI@xyLW_`IxV*+^6%*$gJjaaeBHof>YXXWJ8<9(#
zQ?40nD8srvo(hVW?|<u-kwvnQ0BX--3<{%>GyBq|vzfvq!O_{ht2|=#!wpEZ5i%EB
zPbBCp+@^pT_R3tE=7$15EZLBMhj_;Z48;dg>oQYGd@xb9N%<N;A&1|f8hMepWK$Qa
z5AX8wy@auL@FX`*3fQpQ3uVnWn}?cOr>M+zm|n(1v^rhHPUdx9A{|D;^SZ1Ta6}Sp
z=T_{SD_uN{8NJ{0BS{%-E?(2jo5<a4SGOfynkKEqKKJ9*OuM}7ziB;_a$6hT8Y017
zDJR=o!Jc=`=>g;$`?h=}^}G0GEU29)lAlV%t;Sf@2ydK4$>gg$-UBG98t?5pt(x!a
zL{xqe2pG0@DImmZdXeZHXy^d({_7+!cFGTe6YxAAVkbWrKs_=w;j48aYv8+gn@^KL
z!4Hk1+y1{?v6{*Qd`drT*<3i;b7Tu{QHuGCldDwD7A4qc5Gvx}|MBAEx%@W-St9G#
zs=#5*OdPHU&PYFyb$bp|5xeg*$>mqqiqE15+IcYlc&vdYBD-CB7(n=~Cmd~odLjP|
zT41r<e8S-%GG6T=wh!ZfLw5aN5<j!dI!J#HuvJP7={utoO6WNpm(e(6WWDcI1h)E|
zTUns?+%1N=c7*q5I|NG3D;}1_D^J@#(*wpjDc{wxR__#~e<zKx2Ji}h&G%YFX31lW
zq@*EQ`jOEn=XQ-3FGQ4v_pYn!@6SKs|MgSZ^y@FwVl4;<=q`P<fROosXC`3kSQQm|
zBsSOxH~vd&NL;)j<AE)CiB)#wyXu)T?8dj{?0J1++s_oUqC#O7tT}O;KuO6U6~{0#
zGBP?JqA*?8&Z&xXHlF?C36+M7*3ia|u8TyAQR>~>sn%3Dhe99xH(vY~L3{<7sH-=j
z72+at2d7FA`a+wFqd?xaVvo#;hO)pBccT{=ouVfZNYFH%KVyiC;Ayk;POFhE<?*RX
zbY8p2sSR3o@T467w0J6VM>l7W$)g=(C%H-Fu-S;$j|Efw3+p|G(Q&zEa(J$owhcK7
zE5rn8x&-nKm9-MvI7-urD9}KCg&gUG{I6lz1vE&10dwObO1DIY^2tWSpwbf0t2J+S
zz*QT!2=3OL)bT&RS~|m?^55^tIw|^jmpFYMlT^f-z61N)$A}>+p_F{_5x)QQ_uILu
zMDqDdW*C32KDFj+bTi&c^N8m(#PUO;L$_s{`l`moZ#FIYbCTrM-o^PVEArL|62oqJ
zsaec*ytLM}4{m-!<`oBCWz%!b*wT$&@E|o%cPNT)d>d%YnsOVkWxQXvhljEa;6j{%
z<L2Y&c#PwshpJ_gQ!Wv@Ir6deoXft-2V09bdRK4+drso77sXz_bZPZt4*R7WNL5i=
zq_3yWP7F>^FDkj+g36LFrndz_G2^q{bW5d~4(Rf@o14G}*k<H`u(4Wgk&NCooG@@B
zJ;{4PaY#d<<(Xm+Ktm_zo4&4?*G-R{!*o;-AR+{GIbRh1MMs4&)(x!P_ccU`0-j1j
z)O7V*96_GsrYWA}+T$xcOnC&SNEOR-X4@#5pHOD)ygUV8iKNZ#SBNyHXh%x&GTSo)
zUiHYN>XTi9J(Yk^mmX4LbOcc;*79W_T;2@$y|=zEGn*JR;JAcJo>iHZS){^d%F~;X
zfR``T3%N4X-oJ|LrQ8Aj(sQ-vA~O}#$2S4T5$)6`YFQKkjP;yU+sq6FU0ghMPX*}@
zId9R+@H@fA#(UFbo!;h$NX`sGyu?`(NtUdyhU{guaFRIu<JL-Hic`IZV`@Vi1-{Pm
zjdRuZH`%SQO}XZQtD3#f+bvjJ$k;4YDsy{yaSWVl;+Z?VFxKaI`FU96gR%8Ly<gH%
zu?tSDc%eHN?GnRip^qU^UaYJpl9xSL>E`eTaztP@T2(8)F7ZF#hP-6rdbXs$<If!>
zmHWRlG`lWt5ch}(J9dh&Z;ab|ypjiU94}dJRkQI~O_~n0B+U3L*;nQ;g$TyVYjbYH
zYRV+fhp|sGy3uo{Xyd5WhPiJYGrW0(c6V>n)h#a;2wDXv9e)yjF@fRuOzPTZ>r!&k
z@Y2m!9PL$35hqNT0z8A`_s$(SUN%Sg@I~yy!>gv@esMLb_h(lmku^_!404VQOQfcU
z*3K)E-Ptp>kC}_0cv#3}axr)IS{)JUc>BKFYwWjZ<D|W~bB!@6n8a>PZ|TNkXJ!9?
z$C~rL3lfvgUw>-e4Kj5v$TZ(h9B^=^?C^XtUv^f^{QfEN)CNZtk4YQ^b9YC|7CVhY
zU6B{>s@#4kdFi=q(>%6aVSF^Z%#0+{WTgWGEvM^GZ3f370XFh22T(I@A=-7VS0rg*
zGRW~hN$3EXAonL{>mh4gE1eN&wh9M4T+a(MpD%AI{#YybG9_9^s(0~xVM+qmDx_rT
z$$Q^i;U(pk6M5TWf&DA|A@|YWYnJ{UCyB@eyva_`xV~n-{@zeivKaKqrbm&!$`C(8
zHc%7wu>-_N5$X^pwQ+RHHI9g$JaSMHwR;jVcy$lJK~Gji?zqkBDc-u~B65(Ea{v1~
zCxh81;V`y)3MXlOOa21JfYyKlPJdfuR!n4|Dk`}K;>}zf6Yk__$d%O0up};?#;ZcX
z?_l|R#qGjgQd{An$EGY{tlNcxIqrJ+U)p}TH)XZ!4k9tK4~C}&w4HRV^cp#28S_)O
z6!Zdv4f=j;b;|SF9d;;_6E9u@<E4dvh3e2^PRd6<gf%A|s&ojNl!(>~`ENd;YO$X}
zY{_z3!b)7TNLzHf^qx5sC+x>GemjagcxvgZXF05W>ISU7QhZn4XJ8$l(Zp5V*JCqZ
z*+Kj0djS_i!kjGJ{pn9dTu(5NXG97g!w(UH4k_Eb5(6X27Ir@Ht852Su~%=*CO*Jl
z|GK?J3!3H$)9GobK?g`G3nnUz`NP5tWXe7PxMCUE9c(=NT+{iifH1p#Uca(ZkEzI1
z_LTbeYuW|(1~jK6YbD~AFd2Fu!Np33k>|44f3I^*wx<VtL%II&Y3G7PvDm*=NtffO
zB<xcuNEvu5Pkzcn0l%QF_%L9S!v&-<W__V&b^!ErDhCMJix3CrANGF`2`$@uR0v7Y
zA*N<#D|e*iC4T`8<xNG37Y`pM)6JXzgn&a!4g)`bBLATXWP&q~LuPeU2K`<4PR!OX
zOCO;CtwupAxi9+OQNFtQN?UEREB$_#M%}uTdrQnm)R_J(5)1nxP9GvQ_sY^I8!!Le
z{tZgOvZob+b3|0|6p7?1IHh0y+jctH9;}(rM|{V@ab2xxVCm6e?DvJVox$a3y!{FJ
z(5l__a;@?_A{l=-*`QKPH+C$={*O#l<ioM9HK33_1k*?f+61oZjcv>A*XrAtRM--d
zoC_;V#i0iu#g#P4srMk=u<;e)N5Mrpkz1*lfo?>?@7cvtW>oL^lfSQ%M6jw{)2wxe
zonvG1ES|Gd7UGtcb%Xmvjx9@Mfo$!i`C0WOZ}|iDjDAUyCTp#c^iO5!QhkIdthGn0
zw&#6aKLW!G190Qc=9^F>yp8z+9_S9=c<Ltik469SwQJ1~$J24#L+Lym8oOV4q)4sC
z+&YTe#0b{|(=1bJz|U}AuWJTzPPe}Vx-DU;u|h~(Db;&cJvlqV!S7>)H=T5ksv9`w
zCKHLz%C4wmIucJ#g%13<bbfW;uLdOGqKo=!JVQM7tX1N~GpIO6apD5CML=6<S(};p
zTK8?ev04LhKybHj!yH2fO5m}jLVKu`kJv<M>Gs#Z+ub{yM-I;d36FkTff|uv!*}=x
zN%PTBK0nb{BRcoV+7pY}?dR`|;tqJTL3Lsi?6nSfK6u~vu;Rk6E(r)T78?V(IdIfx
zDjc<B^Pd{?&HcArpMB*nxUZUk`0z$HuAVwi<|vtI&Y;V|<llNz9U_R^t{6|>X6n$C
zmYJOmOan>}dlzt+Im$!og8e#s9@dPWwIDpH><F~HUgC;;OGQY?y$@K%@>9Qbr<}W2
z6NrO87Yn97!+0S*G89`Db#SNmwMh*%@LK+iR7`#A!4ZY6S%FJzOcvJ+u`fHbWcjhe
z+OD_4<=I12SCmxwvKuAzI5@02Y4RZ<o)Uvq+!IdEAbRK8l%%n*cl9-rH1u3<+j4a?
zXYScbmr)cR36&mniB;=lXpBmJs(G6B5|M>=k3@U9F8{jZ7v67E>Yb|!*h@|C(Mh)y
zUgc~Q2etvj{Yx}wO$PD1ly&S@`QtIzp@)2Q_vOkrg-&a2?QrCqq2mhwQ~b2n#BFWC
zD1U2`424Vb`Ger+u<r!Vb_?qV5D&h-u~XvW-zB8wLRVpz$`=9rX)Mm}JRCY(eMngM
zDmZJUcWFZUVXMV7WhX<<sqX1qsb8v*FRUPNy=CWNVmEm471|tC*9&$XY))Bq;HHY}
zfb>0uv|Ay_Ep(ivR;S;{3H$Wx`qWeOkv`sos4*D1*{=)j4nA(^1I2n0ZRgs<KFBj;
z1ApI3qO#MnW!asN-7P?J68oJx5t518<v!>jqtS~izNxH@j9o1)<(<`*{@#hkwc`6q
zhec&$U$0$0hy?P4b@EUG2gOimX*zHGQ(s7C{vz&w8WsJzyPhr(WTE{d{2&H<n_JS=
z>h+a$_J-hjr16x#qNKmfUD)YU5T=kvt1mi$X+=65WO_?Vh@Wn)DMuXYBGu4tp_dDy
z=ejK7aT@z{`v%v8{!XA;-ia8Dtam<jcd=OdBpOnJJ6F1%{}cVr^^4iD_qoa~hLN)E
zI8-v|Y5%Q^Z~lL>?nm~TSp$qJ?{{tZds&xHSm9RC(=_N>EHn>~WqD(p`V%cYsN=ji
zI(y{pwRu!7uEh{_KFb&RyG-LLT5tmr?Pdm;DYn!he}js@6H~2_<=uzhLrUxzH`i0H
zh!m{?%JGV2lVM>uxEgX^^*7mh#aN`5n4VGW-S_@>?)TiBw4b2ITdycu)-cZ@pjYO#
zx>U4z_6E<8Xij9~wIk_M<5j*W4o8VTesulU?oCye?L3>=r2LZ^%k}iCrig`y@Iu8L
zuW_`_zEBOOzAu-0oc+qiKRq7~2q>Y}9mT>?m4^aDl4KU_WkRiAmF2zro9l~wzdPI$
zETVBi;x)JhNqrmlv8h?R?g#w|LQmz!0gH$P07qxnd%H?4SxxIXwY+rcv*t|_ZQZM(
z&%KYP%_vSIaGNSl6m{@#e~tycd&9AFMD<!_Q-Q`#<_A-hoR!YhaSo38XOoq83=GzR
zwQ-_Fb6@L}utIYQmxN)E*YOGW=Y(N@na9viQ~hkjG6}k+#3Z_r!@_~{F8vk#TEUxY
zx2yjJUEgf8i7dtNnN*eEwa7ieBLuYA-Cy+abx4z8q{9x(+6|enmlnlpJIlO|bXK6o
zpTcwhj1gWCh@v^{-t5gB5nyuufhkX7EsjXZgq=d~*L8pOJGeOPmu<{ou>WN?1UPE9
zZ``eZ$ut19*Lo$?r55v(*L=>Yy{n>j+D!f4^RfNyI6P8Es`l<dpbKd~wS-eSNd~_~
zp3vKL=4<7xc<ZcE(?9o#`d3uj+vLb$8RvE5uNKl3|8R3@o|bH^ZeIJ~#{@i=3Npfq
zrhHST`~h4C{~h^$>dslGJ5x9hI_3VJ9#N~Gd^V^*52ER*GjaV-$ncOhT<h<{qIDFs
zqAx3lWlbF9ZnR1}?tk7d<echwaq7sdsx>wa>338G6iMfVp$MSqalF!jwc=?0a!D{w
zIM3gAHn>n}7DvRoaP6NVZf{ajN~t>zG;UKIliC59Uc(wUG;&o^w9@Wf)>TtThvv|)
zwrI1LvGwddW!=~_a{g-f3GKjq)tRt6*jBpgEzs6>y!WbISVL#uyFMAbd%w!t@aD0@
zq%g`gVXXDul{n72+|B#fhOX##+=q(zKGM%W(JwE){I1<*_M##-O&tcSQptQ<UH5}Z
zjFPb}{2imJUWOb()eaBqAP8iPM^>w<b^ay}^7o0?_wN0ZqHVEzmMM{KF?hJ)yO@3X
z!qM_i>DKjn-(^^p!Ybze_skz0>(B}3TUQw=qxAHU!3s5(Ge}lso^h4Vji>~1lAKF$
zc*|N#y7QCJ)KgDP+V2NHi3~iS-%E}s8T|O@wS5z}q4o}=ZOEdY_!SC#dZO(XTwq7i
zM<L}As~bBFRy@@Af0CCt@`xrO0r%J&f2wR6lyOjz=W=Y#v9}MjG>$umn*(5tn#=Co
zc%B?#T3@_krB(Fkr`YetQ(RyT+#wQXLg?O+rs8r!$VtCnTaJXhaZV!oh+e$*rP;9z
z@u#M0Q=M1R7b*x4f2-d2Z+Cl7OjR{sTw;G#;_`_V3U)(NOBIAyK7K+=*yUpH`KJ3R
z1SQ)+Lz8~0=xf~^&RZ|#__(DgJz>a8G$ndaV<+vOFSp`(HJ22olyP%{<-M4c&Mh}V
zUo%0c{N*?Ze#H9!G$`qjHx8x|ef^MsF{+|3B@*)Qrr`|ntt4+UfEtD_i7J?`SCVng
z79@`F=ov=FfxSyrgl>HORwifxj)M#l=l>DU<7t-u&P&8`qMZ+cGl-gh<uM2Rq|0`C
z=UVZUjEpt&p$Co@>e*QndrM1AEl$1SWOO+{>3`oY=;K-V^m4*Ovx1m#e!zmEp$n-T
z&Msk?8S3n3R^MW_M`068Mir!?AfvIn{GiZz)AQ}GIn|C2I2$uU92=vAmWIKLTHW4a
z>C$blOvnDP3QG+4LkWb(d8-DPpvc<rj9y3E^^MS~&$AKN*uNta9{;E$rS7vJ{l<?p
z`%B0qzXT6+@TB$BXr(f9Zh1u)_lphDlPR2vHieZ(_DrHc7k!d!fB5X5hu3xOiuS&J
zzR^%tg~HTLBM0yRnQ&CQO3^zlX^_1xiZAO{pZ5ZLM-??50cU=_`nQ`{J&bOtj@f!n
zaH`5`-*#3eRib|?I7c%4{E_Q-ww8%xu6WYirM}WveuT#4mosmEWwKNS))?<UZbN4u
zIUFsu3sBN@JMvj1LZP9z{85G|a`?yWhZ0Md4_nexeOzVc7OX_Frm!&K;%|!EDjkmw
z#){5M+u!|js;KSodBBj5@-N;R{vFYDZ4asT_BStI+4UUl<MOYvM^cYh0{2G?^kBtA
z<Hi@w&stHbY<0-DD*-@u(~wbNJ@og9smR_3&6`)b`Keut6?@&#P(u$HYcnD2lsIAb
zxo_S2Z#izg2h55byLq;aZ{r^*91KD{isJL{stm6$yeTZUD%=*Gp>LW`b#${{jk=pG
z9Vddg%a!?=R>rwTmCd)F9Wl4^{D{Rmj|OzI@JWPYW`$@{HEAM+GM@8~?qFkMo0{5t
z^Mx=Q8-tCYH~py`tpZy{s(9Mwn)*sL7$+MGg;T<^niCuD%hPByJ_=t!Xjo{Zyo7{t
zl(+E<Zew4X6<<StNNw<x?}t>F5`0KKt5xy$Po?>Xz}k`i58bun?$RE6qT(2!fk+J&
zgiM@-KFJ(&FdJ>*^R9EahAkWclW#`6n0N>ZO#|Sg-xF^8(FTbC%Q<iNOEuV8JG777
z`2nBe*MQw~cMuQEhL(dBdEc+y{ek_kAx>iL6)eu%M<xQ^wjR~hqc@j$$>F38i`yO_
z_1{BX`mt8pB)$%caU&FxeCg0*s$Qsy4WWP&p9Q+X#)?5)Hc>a^$o8ANIAerY9wSa1
zrGX>)N7B?mZ7_!gsnnVukNJ;%YG!ArvoS|$+G9Nzz2TeYS&Gch8#7>3DdyP^5QwY*
zI{YpJ0gZukSnEfE4-}^EFIYdW?uu0NP}7iw`_zVWs!<~9?(2bMskey<IqEQRYKg(^
zgyM2<oDz0a4?K?f2c+GVf9Oin*>E*>`k-_iHflM({-ccjoIs_PefKa0U1s5yE0%h%
zvH-rQf|L{7-trVaTN}m?t*qOOx&k#v!jY1k43Eii{{X1#hJM{w8+BQ#tMPmYyq?!Y
z>z#in9oZ!P$CWMD761x1T|L!d=|&ypNE8rk%(q`CmjFDWuTvlMw(~+2vxBp>)W?k0
z1pq1&hY>}FptVAlC`Y>R0B+Jlk^M++^*1qdv|%r!&pYb!U=i0qd&Tz=&HJGd=C#(c
z?plO8Ho)gw;|Krf-@zdZIr*gPl$W6A4%U@LyL#X!NFXi(oZpD_JIcUGn(iT22-Uc~
zUGqKPg1<{l6J%qQlmMvWgz`uJ{h@3${G*Y;M&;Q3bdiH?BtCF+JUX=`GuqOo$bHdU
zumCJ-r?g%w>!jlt;EB+C8F3n(JL~(JCYW0)>Rue%{SK1Z*-#3+dy%wP6p#mh%pxtK
zem6o_Xw#!5e!Lqg*s$ssr<ACd@4o6#UOHI^xx&U*ubbzvUQDC})6!5r+blU2Q+GjJ
z5;%F6IQeCJngU`iJML18mQXefxOjE*EICFE2vIEvg!s)3ZMDbgFbj=z-T18K3-$2#
z4|zCfWB<FIgR)K!!vnOUo<t~ayD3!bJco)!!>B~pR9-`_aqvwRKG>)(cc|fV38#!C
zeo9Vc%I*l$M`F?gmOazeV4Pujb@P&mF&Nv_LvEIX<xvlm^T*Cm4&g76RLXstU3tKk
z5XUdyU!X(!Pjd2-O@@n0NTcP^>Y2e@m(Gxv5@^V=u+Y|2jq6$>?}rEBy$n-=dD04=
z8?e`tY;NcIK%Y5F_fzc{LW1bjM&r0KGi@s;%s8j6aNE>%p*gBuysui#f2xfo=g<;f
z8-pp<Wa8GLz<OV4cuiFy9Bh^QDRhCFSVqU^^K0}aP-%Jt^9h~%CCvwEO<h5^-~b`E
z-!FJSyFl>4Ykp{cHrKq(KNm767eED(CP#PqueHBG=9nAtBT?wk%Lqq9QDKz_^T;(q
z8J5%<vCK+kOMj6k3_fKukpHcMOD}<#^0iZ6e8lLlNE#(!$3MTebCq3Qz(=E+bzld5
z(_)HT?}S$%&Ry~G%*538to_8AW1*qjG5A;JTlhJz#ZC9~tG?ppVk$ll0wwH6yq2Z1
zzkKQ6p!)-x#5~2c)xl=3p7lI-u~5lK>Uz{dms$R;OGo|yM{B^Vdb0Bd7HavS$p@Lu
zyrgdKiK*%g>p!s6tUGz#q0<kcV|e~(lsY}bmb2qHD5lbLZQzNeurFksA@=^uUrH;>
zPaz5UI#PRf<#E6!9Kr2PPXXdZ8O1*zLL2@yIpEuO!&Fy=^>`6E#)p{ozy8K#AC~o)
z81u2WbId%EZqdpgGUZ|vjoqp={h=Cb=t3p&sPcTq#ZEg|k9rR?JiIS8C!<nX{ZE9e
zcoauCPQvX=27r?Umz|4bmH}lOLm<8al8L^J<xAaB=XvZ7C&ME+CP@$TC@-4cbx$}J
z2!j^qs&Q%&E37f=IKx%+C59RzwVN!3bdPAm)mte;(SKtLG_XBQKLyqTk!&1!`Jp3s
zPqVJOb*#v$=li`Z@9R^=bb{RIf<y;8m=C*<v1bw3cNf+=%`BMvxc_GL!-aOdtot`s
zpmC8nk2yGpnupH7ZE)2l-XlT@8S3`P3B2=zgmMqs8`)!>uTO-(IOC3EW!DM{l5;!<
znK`9#Qi7u^QS}}B#ftsxbXsiayD-YBpbKgTwlfSzdS6#9=Stl1{@07ZYtm`?r#KEB
z86Z^uEj3|_xcJbhiEvZ+@hk$Fh>&*IMx#Srlmh=_REjtoMck1!!V9%*^3fLN8s^NN
zPmN#*ihg+-1mMrRn8a70>b-xLx(}M!rM-UZb=qKlaD>Gden+Nxtep*LHKIrTCis>t
zhXhuk)?ajHx7bj*UyqrSQg-O`iS}Gs|5CxUfyjc-iQ;+`%_HL)KO|pnHPNn^z<Bh6
z29-q=c25+WGc}m#&42AABJ_Vg{CxP?%C2MB3QKx!_l;T8cY6Tid417hn{MO}SOdFW
ztr9??V2E?)BCpO$!`ye$t}3XIcr>n(An0;t4^99<tdJ|Y*0md*gFR?Q48i@NK4pb-
z;t;R-wuDNMV1CbWO}qGh<(2{mdqJX4{OT|Amy8S>#er5_kXhMhb|Y@#%f}~|H|3(d
zUk9$V+vwoOW6o(>WwPu=AWo|_V@`GD%jn>wP$TW<`EcZUQ*>~LSu<7Yf<b7Lz{gl2
z?L$nhJtaBdxrjU_p|v>u>C8;$z-C(LXz3V#i-r#tWqHf>nR`5W#M0&zflA@o(N-Rq
zT<ZJX-Nr*XWODpAK!J)i{hhm9Z_QG?dEKFW`{>lW-RbXY0#dGVu@7V}U7YeKAtYfS
z7l`th-NUk&>6hG*8v0I3AbU%h*junu<$dR-mwEgG4r~aLm_QY#g`z|2uiFV*O%I8{
z^kgEDxWy@)ooy>>+=0w3z&5I7Agvc@NQ2f+&>5S4sSfL5TYxNwft-LNjE(=o27Cza
zJeb7G72k}q!~|93{3(>f>$G#ok*~ZtO+4HZ2$ac1Oa5-l+rH{Oj^*^T{4&Q?n!fxz
z+eyxW&aeyf*1q48ZOmJ4Bz9^i81H0-jxJ_bh_;Mtgx7GGU!JVH?~l!fWwc-DcNn9$
zcse=q6-vR41rFu^R9!E8bn%m4_?%PMKl9!-7I&Oa0XF&?;Z#sL)_H;QVWph7u67B&
z>G-mW47Q=DW5iK1{1$^Rg)-{^j*bCi<H&~FUij#x)w-3l<Nb;Uv5OfYrp)a+)Usm}
zQbdW%gO*3c8ctCuTcs*rOZ>15Ss?6pPI@G9<!*C(yN+HJl4mk1d#O9u=reN?yJ|&L
z?i_4SBeZbei6irbmWTRzx+=(u<ptn8_Z2ePe}~p@y**!Tb#f(wkGChY#k5Q(DiHA}
zQAx?;-eS(_9atOFy~g=eydHxdn&FtP9M(<aIPy;SP}j37njQC#QMjpP&)QeM(w4eB
z{A0^<ZXU!f*@3q1#LYMlow#n;?2i*%w2s2Az>lmXRY}ROmOBlm7`R~vf51q0ZYmVc
zC0EMQuM7?+HeEd+>TO(N<ob1qJn1(+*7tyYUYCr6F6^1sBbNQVcR#7=ytDUm(4qC8
zr7d@&+<~W;;iW7gIxV#ly7PZJ9|ED7dzKW7>H0U35FGQGiC&R92sQP)qxl$>a`>e4
z!{)1W#gJDBZC`yBhfhzP#8tJQ`XSo7%5q1lH4c8zzVUL?!VT#<si1@_4*$`8x33#>
z{t{t6>kcH&6`NfSxswQtXn%a?;-vQLhYCJVloIr7S#u+$j+|a$B-S*`n5^gyDn<KA
z9cE#~wQ>CmEo<u6gM=qNpeV^-5!9U<hFVTaGfr{G{R<#QEi=CrSqJI)M)hAo-@(X;
zE86yRQ|xexw!ca_93alz<~3x7DihbZx)xKYlb73_!})p`&sb~Lwb&^2a)A8DqBl}#
zqtaj~$%$PUS{r(t^6Q~1vdc^4aNm;c-(I%{p56v(;0eE7bNFb@rz<BX{u-Rp7W?|@
zqLB6`u)KXdnK>r<)2ktJ5ffBuK8qJPptiSpz6dkkCi;HB@2hkd;4+JtqNh1%DMpUS
zU`mTCQ=?k>b@_kvn7<Q#^mS+Yy>HF4$%@kA#q`N>d$3go6W>zhy2o=W1%QRjz>UWj
zHHiyG7>7I`Rnm-DqTyFwyZc=RNYT?tQ67w*jwNiA543Fa)N}41%1m^}2WS1D*-Fzb
zBPy}i=bz**`;Zz40Q<C_UB_vInSnShfq_sFJ<UxEUyoAvS&xSlO^CMZRaz<tA4cT3
z#Bv-)%9<Vb_&fIK`n{n{ed;}p{A#yHE^Js!i!DL;`Y%7!IL~I0UKOH#Wc-KGUcj`s
zoGJrdI0ubgR!4LpZ~in|{W_ugG`IQUcZ=rCo5#w;;;<c4IsZvM%E%_Qi|WR%?#+}k
zw^ho`YG4cRg+<J!6_p3)(2KpgV{zwu6kGXU{dxIl;?EACe{B{{3#S*M6V*;hP-cCK
zr5_=@J{0{m?=MB;js3tb=_iCkRF!FY$#lNGojlGsxbRDZwS|axoJXqJ9^|ornq`iM
zf5Ur`?Ks^ySt&K8$q#b=At1!7AMY#Xq^tv9quxjf>EYARa6y%%PJQ&`|LHEA-uN<f
zm=Jlx;JG^dA_{|xP}}5wSJkGnt5eDbq67p-H!0;SDKB9~jm;>@#GcAcM>-w^j-bj1
zOX!gtSZX&iqE#+1LIv$V%?U@Mwh0UQLWfEam8n5RwRMffcTv6YDrLn*)Hu&7H#v$k
zS;^;>4ILn>B+70O`Pc<w60y15tM$)!M&%qPu+fEv{tl(y)gC^mFMT}OE9TD<Vde6n
zXcBSEn%5u7=qJOz#w+oPEEBEQ*9Z@8043kRqj^<oxV1Q)%0%_m*ZB|=Vy^F@gIiV~
zVs`UGn^FEz`!EToY}7a6mHP&FJx?^zxP_KoXRZSYvy*0y*wO=RNoRYuVwukQ{R&Q3
zm(N_CP0zA28703g7GD=zhMx?rFs?F;k^`FjSrN7USHgFAP^gjy#4dDf)-RNqpLV^d
z5H7KFLN$Y0lePb_u?O;LgiLC~oNtRz1w5%ACMpd_OI?rEVPDXCWUN<i#hM1-ica!z
zIa`xDDMiWgau)70*`<dF2HgCl#`qmkd^p3+`Oi%WCJN<^NN6HH!|afI&7ZCWwIPZu
zN@^N8c{JTDrTg{pdLR>T7N3JFbpL;uh?-=j&k<BU5l<lYl1x(;!?sYV&OVv<%tw$&
zeT!4HR+OCNK17ZCC^<d!og{-6b1dE+Ofsg$QZ{bEl(J@#5z)@u5CmV{c=6cpm}3#*
zj_efe`Nx7Bzc}~<GGA%41*e8iWR^hW^k1|t)FDyF3jWjKnP{q90tRH;?q)-yERgg-
ztPbv?=<fEDb?CXkF<Y!e{E619eT6(Ed%B8Hld*l>$5Y?PW^4b<v5<okC&{129F|mU
zxxI%U<yLjr)`!ycLNz7=vC!iP!0sadD8Y$9NeOOHFFodIk+981X_T(q^ucrDWz>%7
zpINs^Sjl8jBR_2I+_QDfCiJR&JoP3Av<n{SkXe6)q$OM%!+GwKci;H&=#K>w9&j1z
zjCif_qp%Bfw{4GAQrIcOGL<~fwf8coQnBbdXd{&gk0xN!a8Tp;ba}wuM<>QqIxp+N
zQLj7tUNe&^qb5hROMQ6PN!TS03|;|BG&Z(byOW=_Q*V}J)6=`;_E6B44}tbY;RCmm
zyd878AQ0xdHu|6hssDmo^e>^I<(z}`kR?i@+J1E%|GZkH_=IC}eY|wkf7882iulCG
zE3Yi^^+91?vvRh~(a<a^u#AH!JM2q$4c-Rmg9yFv|6}h><Ed`L@6l{~vu(*XtIV?!
zD#^??iwupFxdD|T2^rdi3}q;#K_V5Js3bCNQ*#*_M3SK*Q^pY0Szpid{LcUU&pB_-
z>+{a%gT24QeP8!=t!u4yZI&jsDDx9`SYasHqiTrwA)MO9q)<ob5v9Q@yhCar6jE+Q
zaY<z<ut`u5tWbI{$-w-=QiikT|GLRMt(mz|x8P@_l$IM;N4j_SYjSgjl{=_m|L!rW
z-i>W{N=E=|{a5P@8sk~J$WV08$m7mi8*A>0@_%@EK=O=|gK=8$m#2KsFB=|RXl>yj
z)#*$+IyZX!533yX94)D7hEtL&ATNvm36*pg5*S_bt+E$#y{#YuI>c={j91M;YB%Uk
z62*Ry8=n4>iGF-;GU@_AIR7Mxx<p2FT&ddp8t&X)r`%7~oD3Y?jF?Mz4IY;X#8j@F
zQw|I9l;l|YBVX9Zp~3#@@%yx!x0OF5NvYY+lYKtGOD!W~PKU@5jD<1nK&PXI`$e9;
z`E@C}D4Rs9^2c?0;^#xxWoX@HIJ3NEf^>)zwUF54TN0^*{=_Cv;?@>RB1K}-+Xj$4
z&0Zh<Goz>vl+Hnk;uN)jN?yn8U38ZB<=nFX?lQ&9hV2R58x|fiO!ob!7=22gh6Vcf
z^In;J=k<d}nEVPhqUTTG*kl?xl7rVT+b=t6=z8<{YC;`%U^!t!{cj@9+JrrBQ=eSJ
zU{a$<l@uwuK_vWRz+-!7YL3?4bx6LWFDoBJLLEnq1Z8Jw9VPQ%tv;H?Hb>phR_&M?
z|0g>jQa4a*@{kcC<G!NRy}z%t+ZJG>CBIg{w-X&(fK6Iu+$s&1)AjT#<C<UbFNr-i
zNX-g+A^?5LbislJrc4%bMxZ#C$psAqfKa|n%JO@}w{x%!uXr&|4M;9Wg1RK3QzCed
z)s7tP2HY6B#QqKSQHtuJKlklHE_lr{HHxr>?_A9i$4Xc!?>E`M897#QGXWlb9e--8
ztU3~BH;+-Oqc=}kotI-n_mjmH@o;D|q>M=Ig|-(ol;tf`jM}TmAB-2e+m2;?s6L7h
zJFCDlnY&g(gs@|`^@0j<hMw*fHvcEn8d;x(s`pBG-H_a$CvR@Nyli+GHJ&+6<SRgN
z<9fnW;a)=!2tF_FR>8XRA<!T%x=65GacK9N{HrBWB5pzdzSuZntc)g^#4zG|=z=72
z%nR5QvIq(?IO)P_qSp%j#=ouiH$!W8A@2)x@Py95C2MH^J}eo>R2Jep$^wyXL3R+3
ztyS4{PSr(c>dn6|Z2Bl^I8l8zY6JX?#sm+ByCetT-o6PqVme>P79Ehhs<Xgv?Gs-q
zCAg%~9q@z{4JU&s+p>G)NOuHgYOL@bO5|Vu&JOMN&{ntZ8S|Fg+k1bk$^g1pC>jYO
zTf9Vw-rLJ9mZLW1th~Y0bl4C62R>Q|bc!TqZhRg>f_l(!a_D2rxH?f9?lX2rx&5f5
zkU(DEp~h~hrvOZ*%Fn;4I5|9!)T{C3M(BOg1&x`p+l`E5Spm1kUzof3Kv47+@+P<R
zPBA>#dM*qbG8PdDKC-$2N5TqZSDW%udVL0u5kaqqS`Lacfht{&kkmdH4PW#h<4ZCC
zTNQFfVu=7sK<AFfd|bmzW!cDmfup-$o@?@xm_JpZXQtA!?Q8X==nPzi3{}8MJAs9?
z_d7uT<QA_?8XN<y)9?s`3#z%WLqqvWf=92Ys*bdA^GfKcYa#wpa5*lIivC@>EM+qC
zA~Ogb<6B%LzCM6JA-JK3jOz^N8hNCAF#HB8yvP30EtgLJ2WZbH8C1}CV~mu#meAv5
za7_-;iMP%u5T}d)Z|_MpqT0{^oHuRTqlJ%pMIhiWq*TEkde!NG>E1vI(RcXow0_5h
zROmREG2h?4f`DQJa>a_wS_UpZkc!mOTtox|2l$_?%#_%Yzzr$Y$$*Z}Y_5NAfDrme
zwKfEQM*tG`>Un<8T(M3*EO#w@zl{u!gLP;XOzn9K%G)~J#m^&)IPsp}$`(S3C9UpP
zP>#`ji^aZ(>;(vl+;s8lnU7uhCd9<%f0oh$Hfz4V=4;&0=ISJ^$Lu%iCBvfzul)(U
z$o?V=jTjU<AJ+x_=vbrWjG7e>cI%ytF6S`a@{&;0_i?%hiE~aX5u4nrerd<H6#T%=
zK~ZRpWx+Sa1iJJ19S2~N=YurHKZ$@$nX9P;Kq4XnQ^|dPIsxBa;<%JCfzF+$S3fA2
zZ5s9@C*Z+i>X=h~dJ(Z~Z>?kI>g1#MAvXRWs1zW^i99pIq!XGJ4*xD-TpYbPiEbrw
z!&h59<Fqc~KsHf{4#IZpyushOfDqbc?7&4*h(T<O*u?ilcx)Su41BNP*YlVMOjdFI
zu<1tkKB8d+YHsWfqA2!LAPx;IS5#5^nJF@6v|}Z#$@tK2v#gLi9=3Y*OA={>mV8$J
zpMC#=ztb!|SzLE_;Q^SJ)aj?D;wp`d_z5Hz+a3<=dMXCE<NSwbh*bCTz?)p&a44pK
z86+?4J<Km0+LG$dPENzMF}{z~X#dX<x?I5f{jJ4lz_z%{G>BZlR<B(-pHC7*{|U}-
zfae~w)o`DAo}XH>sOx(YiUO~aJ8;2#3x3$Yf65f%I`pICl6jI?{>8`R*9tJ4=kpT|
zA}<T(@6_o=-<w}n6r?wItxG^4DlXM|MtNEANKl?%F-GaiGeuyiM*7&2ZxfaE?k&cS
z(Bu|<`9LfZEi-%c=>p42rbe)qC&Kp;#T|1k3FUX=@!0}+3%r)cna9ujJoC+hk(lxb
zZbNl1v`Jrw|5J=@kw(Xf!;_D39SstDbg#au8sN1PD1=0lTs@^@kp`R^nZaasz(mYP
zSpRuTw+HVQz_sk-S32k8L_$))|3+feIV%Iur3JcZcW+gwFT^JtAp;A}OXQyGoa?M+
zuQC_Lu=qHdir#$v#N5m^(xz5^)&{9BHi0!PpqAadKr6#LQ?X%MEVuNRPD!=ZOUTf5
z3$|7C@euJ?f-|3v?<ccyr$>RIit34D^Ox@$B(=(E8MKfS5B9!Z-##EZe*zoJvt+))
zC*G%%6*&(Ow!)zF0s_~UDIMqe{CPLMbImnC`sVO{z8+la70aU}fQP(-R4%$&?fIbE
zX!mQCWt$3IKYhNYh1}hJHF3wn>gR4s;OY0*3rf^yvY^H`0@;AzWHe<lj(Hwfunuw7
zK8XdhNn2tj3~7v8t)EmAorv4Aktzh|^M-TjD)jUc)UP~`UXW!;w?DC<VDl61HJqn|
z^=~AJ>v9Be-=QE@YvEgjdFd}VUdE=L+_8{1$F39Ssi)S8h9M{D4EjXkpn$}3CFU$H
zbGo<F-eAiu$J9#bI6S3Ecm}Kpa&Z6ZOwCl01BR&9TuS^RiA>qhqTI0@sMIpI%JTHp
zKXudOtoVsGq!P44S1P~ysII)0@VlFu7%l)D`!=1;?vjpte-0{u*-GhH>`i@ZOthgr
zssotHm+WY-JSy`p+29x9fR#)%=#XGKJky^hkqi(rN8&jZ8B)K9v-R@Ib<=8WnU8m%
zHuW4P`drPZIj!2IOz$bM?LRbLdl1GFeFTIB(?Iu*9eZPGTVjluZXeXP6~zUw+!^8c
z?bp+Fyf36nt`4pMRwNYYfc9q|vgRuWQGPe~m56`;00L?rI8t?&Eq}@p>3AaF4K&D#
zbJ+`*kTpnX$qT$$F($~^THs0%Sjvxt2?qVvb4i?B<V}F37?adm!xzZc+-K;m9Y(_y
zf01Op!Ol#0oPRRsJj(ngt)Y$zUF2Uik26_^6a_v2Lkw;tP}|chKXgpt>-p{6Mn3FF
zZtW1!A~O5mlOh$M4`~3T)}o{NBzt|r5=VDNz+pX>Z#9ygwx$U!&Cg{)cGM;n^U&*C
z-NMh{c(7K9mWgCuqQV{c3_OjN^g69TpW}*Zcjm|zOT9gbe=&X{4vDam!EN_+C(V)1
ze0LJ{bn8db?1BGgBT8S`wd6S^G7tAc53EyKKn^3a(2KmUV=b7WA4hB7A!jl($MfbN
z@7t2UA!gd+e5k`nqrXryru3TCZlSo9WJkc8j_)Bt8~@+aJews-N00y{@^LSlrb%Wn
zI`QiGj7f&h&o-g!3i*4I=%3ete1;mbPRT4h^19kFw4!{_uB*Ge3J~ZP>U(@;`tcDi
zQn3^(=PJUl(x3PDs`X?FLBsbv$>zFG@R<bpeSw=DG5I?0I9{#H2?P(V6;Ah}v8{c1
z72U7(Z~?2hRJC&tcwD2KTyf%>f3!5dJFS@ft5=i1VBjH+-A~(+_5$LbL>OeQBVv`{
z`e{#VV&^W_+%Ebl*G}>mnsd>&+i%89eSEO@c*jt2oU5~J>Dmz{8+%-6jbHciWRzcz
zE9e$REKl-uy$jUL-+}kntcr+V3o^;X{)dhkq&3HLUk<=!>)f3L0tb!j>v~1v15_Eg
zK&{vnN*R|tNeyp0aIzPRuGhjGsJ+Dh7<A5dXm_74k--@>0h)vZ(4L-B_TvoJ5;AmD
z3}pYpk4LuIz!AZG_UV#ruGWOjH@7rFqGDVgye1d;zN5`ek%O@%d}Nh%C@{^~+3#nV
z;D-QDaces#OLw+N0X6#by^14I4wmR9&W!C^d0boV&eME|^fWLMCRCR)a7KY8>l+-Y
z<2smj{K<IV5{Wf2JCBke#1zS~4L&5AoI%hsri-e)MvQimoJIUE)ddP9-|7+xDYxZ2
zwS<gZk%6=#8xk<;-P0ef!5G_8s~wyz#x@201h0R1G~dxZ(dSz@dKPKuy;ID^(VgiU
zHfpve<Cuul$X~pX&YKHJ3dAluxIj=P0`0vC^cT2^0d3|4h6g$5vcCM)E@-J1i*mg3
z|4JA!bZ0lAd9j96P7ec9*BjYPO%awEjq!5N;hM}wg1}_-)*{0M<IpS<E@k(|=`y4q
zk+C1mk%3(!bMeRd_y=eE%RQimK^Qdwf+Kfs@U~(cczIu?${nH>BxiML@+)Sxd80y2
za!WRfXFbv$MY5S#+=SIocOO<;Pn3a0?%(PzKprIeIu$*f1477W7?D!jo>KOgjI>cv
z!JZ=KuIxNxR<08L?C157#y_B-HxlTzox-rsdCVvNI7{JtD<k!{@-FuJq)^4=`|W$Q
zsRzhxnUd#n-Fu=vev{b$+*gW3bHxFanCL*Dg4c1%G+sGdbIXtG(7^kX1S##FheH`)
zldj$Ivka*#<lx(|Nh^+fU{E5Wo7p0h(6Z{hxXvNV6A5J@;|dkfFL++Pv+Kk$X(_q_
zP8APQ-H;Srm2IZx8tA1($V~n2*Zy9l*ogkz5-q>1tU~AqiQ}O*K5xJvkqgg6V3DUj
zC9r4T)`sA`Ae3Zr7H`2R&%nR$+Pc*}XaPAh;+Id;M_nBLb^0TPtiuZ${j6-bN}N?!
zs?8uvsw@9hUZQ1J8w+}NM935IeZdYPdOPwL@6Zjc&q@3`kqk8BF#oAX<o3%ALGX|!
za|Bkzc-aCss<vv1EjUZ`3Ql?4z2-1i__9`MrYj%Cc-=-x>HPIfk-1-J#nh{}!J*S0
z8rFA*MLUrHB9k=z@fp2E{;AhBHRp=CTr6Y9yi1U1B!<H9(FB}!SIe1B1$vw?(O*r7
zIj8*>iGaDvxy85dr4+28o)FVMg&w2o2@ke>R5kC_7jDtYT%bm42;?sacyiP*_3eDW
z9*S&53{^PU5z;GuLCgP2+oD?CCjehM&)L^H+$8X>cTYbws7@W<)q$XP?{@~Xp27Fw
zzE`rriOVgUV7TaNKh@(&Tm`yY#1xjgBdU6C+NXYzmuPrPy&nt#?&6IzvtM^1udf+1
zSF8V1*;)buxZ_$uW9!(`#Qn-~*u7TVx1{zJ%#f_WY&-0|xJ#8DC&eaF`YdM#XTBZ6
zdM;$%rs_dEcWovWRQz0mR^&;Vh^h_eBC*07=L@;XQFzwUO3o#sWEnd^@?XyDta$<f
zZ8MU?x=jKiYOaFZi*(M!oSysUvnx0u6&2(gv@pBmTDoqUag|inG3?wEIh1L;{gVO4
zw#EDGoYqYNB&U=XrNWRxidHef|0+XUKvv77*6U*#vD@K_K+m}zJR!(WJ-6N+L7Pyp
zdl0snbxUZwKSqz`*trvUc#+RWhel|@l&wz5HK_^8L)L@TB5sxYPF~U<B!MFq)LwS^
zM&J(H9vxEFpK1>PyR63OKy4skNo@5uM6+_P@g=t{4%JpN!5}+=tUqRP`FjhH8DDC0
zeSN}Y&RU;>-@JgDRy=x`()OsTx82{(Gx_85<zR!oa$fY#?=8sdEl_WeP(wahY+Gw>
zE#QbbaQcvEqafbXo$r^D!C=<s5U{2f%8=^^bZbL{^Os@A-7pu9XoX20<zw{ou~_(1
zT*6VOb|fxI(y(LfXASEqJtfc*=dm|(l+<T}rA#AHvSZ^un5I3A6nPBXd6#Hu*OoGR
ziC-6qfX-^#fl}Fn&^F|$Gk9nLA?Hu<Q6LJf{`S)Q?0T_@Hb$zk&)<xUT2hE!GJ&hq
zO>Ec8{eyV@Qj_!Rleh&1m!&NBd+zBLWmv3qAi8q>aSjWp(+W~<9O(I-#zhXzdS+1A
zB+01nEWo$VLas$<fd+flWo(FNK_dc-w*8y3jM#Lb|5|saTI3@CG{PT-pKl?O`A7ae
zvFj_Ct=V+T6sgD(Uxa$kJ?HJmSO6DzNC%IwAX$X4{?Zi(@>mfTYif;eH~8Cen)fK{
zqpcR9k9-<-@~Hr(%?Q!-xvAHIQ$*e|<f%{yZ+;@{2=HJ9?7|YTS4i`#yMx2!!<vKd
z?_ccg`J${iT^(;mAzqwzWa&fsDiv*L1XpLorUT*{Pa6;WD*F1scXhM+5`<B{2A-E2
z6GsGP=R4%+4DiQ)Xk%kY7neI+IEvh1ZuN#y8kM%pT*v_J6GXdz+b2q!^vIN$sKxLO
z7K~!XSnmMrYiy&w{T>~yjfLDNnsI4<-&$~5tnS&rt3X=GQCp|!K2MbK#0MF#ar{y}
zS$`b|8)E_RNop#w0XN7Eo#7=@LhD~}y@#QpaazSJl~JuLBDRL80>*c^$5PPp&PrMp
zjy^(XV$!4D`EpD#l!H<Itm*iVvqXi>?_pm<rP9_#uk=<#wRCdfTGR6YQ<T_?{eIE~
zRm8-OU&NoEcUwTEy*^QPrXn`W{cE3TgC+pE9f=vQ2%u2!r_y3F)HJkd8Pf#(uVre{
zRs(QLgwzxrxf#`54nK!w;VR+m_cjdA=Vfx_Vqx6PF`efVX1H55o&L;YSy}t{T^d|W
zrYKrSR&ED<mSP>v;F3iHhVOCKC1j==tJ>+i@ZVP!eyC|Ru`l%V6WhN8Kt==`cy+6X
zxBOfZ6?G;@K>s7EhvXFpHIs=a@F8a>ou~mj6Y0wMUm3Gz*BL<jTgx-tSKzBmTg#H+
z#~4uUFpe0ZZpg9Q5qGn&U+IkqZl<y?FLY5<)T6tB_q^zW8Dinn`yo3JRN>>0KY_N4
zspzr8q$uOYr+y~?Mi_1{UPg6IwSS2Z{(OdlNB**8d+T0++ex+)`ye6HFMitke_<go
z)r_xFwHWrqPKEIAMDz9a);K>C1$DOfvJ-8Wjm^QiR2uq&xo|(Yh?>9z(8}gjXRCE6
z3~5Kt5`!(|O+tb=vejUEf5v;M|7;(cgJ}lgM;z2(<&zFkjWIIcB%$3e&fo(NO8b{H
zmT}Wiyk&z7Yx33txt@GP{A*viJBicxkt<-hfTl$RC!Xo5!G7H#V_>=JXIO-rMf08|
zTTwQzf50B|@v;$uOkL1-)UCx;tM^MRT&nqU5|vCT_%`x$J)aZj(&6gA6}nnyAU%i5
zYMm~k|0S$flrI1JpjgMYvn)he#mdu&FU7Y`W{Vc1DBTKV*txB?(3SJqBPD=!cTkR(
zp`G4`nr53)>vDfP9M_bK+5z8`x_C3}k28N7TZgTkIdGl!9l+9^27}p`*8&UUHcCD_
zVif`Nt!IIdsR^|&YUA85u$ptftZXDxh)Ouq3x9rwj<{2GM%)M1P!2Jg@qkO+<Qav$
z5-`$4Qx6WMJwt2{G(d(>bozUt5V>34Xf%_+FC)+4sHO|NOj0sk!{~w>iEWMTSM~s~
z4V|Is3^Kj-=~8r7r!D)(EmBz*K(rg?SR~eWO6|q2O9G!2xfkK@?ink2?mxB@rncYu
z9I_-y%eZJbQ~d~n$5Cw|H<vFVVQ_YeP|6R&az3*1L7Bx3F4~w&tXFu?-YQ^}s=lUY
zKA9{|`;8D%6O-s`ykMh*&l+)@iB|aOyp`MSdz&wec_Y?)I_@jvd!8cAj{Mtd;VAD<
z*D}{+<>bL7+JQq`e4pn4+lW&(i#jR#H(XNZkayw3)?Y_#LUs;}DEpSL!-wW*`amb^
z-@O?SZL_&=b7?@YH|V^Fum-hS;Qp3Wl)A}3>E;o9ZT=Fc*<aV1)8=^y1ck*`9i$rR
z{wqM35_(tNN!Hs44X+Of@M&QDHf&rsyyLm7d@U_^pG+9bhHihBxoL9c*VKE`N#}Rm
zIAKpf#LK}>_CL~rrTdyN)o4Nb?%b~XgRpDy87Dm{y#rR~9h@iiC(2qW9??;)d`2^w
z<V{PmN5Ee^a(f4;LO*^%vRpr54tj|n6bT>e-$?k_3CA8KhFvL2T$@^H4BW1*O?$Js
z65(GItE1rGU3UkWN?FmG>)mx;fXP%dho4rsc7N_ePrb+aW<T2rd;2x_eok70qlLQ(
z@VP`?ILU1{pImEIH@&~eKP1=ieJ|0N?cKJS*F8GwMrt5b`D0I8M~_bl6VaB$u&*O;
zCeH)BOL8$|>yWrXm{y0<sB^|J?~C%^@V2Q7t=NM|oG0usJDZb`#WIfc`c$Jv>bBMk
z`y8;S3(eBfBC`!WWoD&4bip+4{8fwcrIfrAGal!kCcxsg<^;;wWzZ3{E(*gkEI&T6
z!}np*Qipwkpprc+u=ln2<;X_!WhKA_yh|FCedWL(s#>Duvk}p4-x95Jw_!U<>#u9x
zXSazi2snP1_s)Y2y2ETeYNPBAdK0U#F{aDb$B*ONsW}^L^JJ6=E~|ZkUxWM6@8}EO
z!Dxmh!vpVbrdNGT)8=I`&f72RjiW_Hd2P?d$FbGNhjNywDHN>dUECPH%$dw!#3<eP
zdJGP_z25A?+$5_ujh(TY%_w<<p86J7aYRK8nNT^)i8Pr)gRoYGNa*B!AH3MWu<t`z
zot-)Z9WPl-!?p8;%cjnbdRt2bVEV4mnY^eh*2aR;7R5QzF!C`rN>r})!K#NKys>@C
ztudnuZi>5d!5|MVR7stP3A<R;V;ReQP*}2k-rLJ9t@J_r$ey-4c#PUntIr*Njna(A
z_bOn^n~S}93-DhHs_(!>0B4lBmWLOf-k_NN-d6nm2$;J|mz;0&bYU}*&<if?>VO+4
zC9L3*T6C6sZ(qJo87-;?6k?u9D|{LIqO-*#nI4u$AyQ?pY#A0YCfd;N9(*2-BDE|Z
zHr`b@nGhDQJnpw{DHqP8Dxb0=3P%%Bz23XYeTNw6*PnwlnB%K8qW#3|>RrzT-&P#1
z5JgW}ma{CJ&yuD1AeKVFu~uZ*S{-cyK4G;z?L2Ze-%~<LTPP$#G3J}C-z<?y0AdaS
zFc|c`I{Eh9c+0niinl%Te$0NvL{bf(y)u32P@u#SyL$|vqKwaY${Vmw&}ojw7Rhz%
zJ+K4ql!?Ln4gKjv52q-7=vU>9rGTTd@%xP^1uZYSIc;9sm41>6*T2(*Aava&oi#31
z5&C=1qRX9$S%tj%M}1cYEpsj@tdxBE7-e}$z{!$L+c%vrqS(|IE7<e@EiPGTdx2#H
zxL^2V<lNTsVE<#j_f8lMKNw%rMml+DYS`t%YOh5;<3%4^g+AO7W&5)<1d@y<)y|)c
zqEp32_qrY$g0s|IcY>J+V@$ynzyp8-#_<upFHPpn*JG}NMR7{=nyfx1H(ceq^ega>
z=5?F%#*i7rMx0krN_n4e^?7Tc$wgPQqQnQbYm4CUy7^PIo2E?G?ce4&$mQ1CXA!u}
ztAh~*tcK`SYxaFeDN5};*z%(nlp(Y2wysYbyqypDHS2^Ch{43KKHy~{fv3vffA)f~
zfasca-vh@rr8uv=YWu#Ut^zSu7Zuh`XP;Ch0{4dwMWFGb*{lQ_BERJVSwWlV0>`Gi
zOR{k$aaL@N|LOI14dQ;5<v}~QO1nRABu2X13)XnLv?bPPJqZ^F1Mgm@Vy`~9=x*uD
z0~W~&rg2?cl~lJUI_jtT-sxB4q~U70^<rz<3*x2x_xHM16VVuD>x$RfZk)jha!yZt
zcwbklZtfQ|S5gwPy_OOGj!GGxQ9C+2r|sRCm8G>uTxDWbw)8y%3u!W}^$wC2%C2-5
zwfC-hw5rmRpuugCqTl4B>8;P1wPd;v2&{jp@pf_Qwt-IEKy27@xUR$$nttLqVIQaC
zDd-MgA)11bMXFRM_+L@FJo}EDNNtHCHIxnfDHMBIetz45UFq++9jpG{eImjAWLIqk
z;jcBmYxb;~+kUNr{zYWUX4$=NRi5%n>e-;;iAGF;gu^51jQWXZ3T<eW&d_j|zS3Ay
zL+EfCnNh8rT73EPU4B7gV5dn12L9e<dW>G64i7EQ+#<&x->VXIAk=?xx&3_s{`oA@
z)!^|ud-r8{;w#@O1ES;+J*zqP$?w3`{u3zCmy89j<5Z{8*p5#6WuHVIU+7Tie&Yh-
zM&9DBtIHG4WU(rRR&3jJV4=dgw5Nfn-kHwtW7`L&M%jnFE{6*@hW}ALbuwT^DiaoB
zEhx@^f4W{5LS*a?%8H(Zw!?;YNO}rMVp);0$;2<qr3Zf;LGJUxzq3B$Q>bXbr7vlj
ztcAQ$#vk0IchcoaxU&yozQ4>W_IK&H;~B7pTw8Covn1KVBIaVz_f%(MT=5rpru>M#
zc-wdQc$WJ`d+o>eGcWlQ*9aE*BrmKA_w9eo)EZavpRuXGj7bv*jizSGo(8-%0WHg=
z?U2Qv{TsVc>&Vwo74>kxBMYKjFhmzG@vg$1{ULV+1>w@Y$J-n23r#7YNAKVLus)~m
zVY(z0_*<a7ZH8k*`qD}yjtiek2&qP8Wf=>;8<Rd8MdJM)^dsaV*t1OcF>f+J5?|LY
z=J0qRUn18%iL)UAyj7M|p~~kEnzfO0CvfcZSEO4rB0tLCThwW{e_+-ct*3)N1F!q0
z{9X9>cYl}tq{}Q^F~@&;V0|vmK->7D@VOJ$vRIpTetJ@MbibOvOOF~rS?hwt=}J&6
z>p!oEXn@;gV~S$$EcWYch20r$yhMJh>8^j*<uN9lbd=65aA}hHny3;HoN%~V*jiJA
zh7)t}p=E>5g3OR_i>s!l%ZxOimpUx_OKF>Z?ACD@XJoZ%>cON-cr@qwf#6>G`=?aG
z5q4m19||ge-RR16Z`n7h!upt~I~<a`!stgxe)B9&-$eztFP&C<H+^8Y$_B)z2^|G`
z_Gyb%&kip<8oRd_n7WJeozTp-sH{5xaO!KqU!<`ys#j$*rT^L)8I;v|Mw3Lo&&d2m
zc0aY0TjKkQfh41TwWEs<e{VKxu>1C6NL^7Lk0qfvAS@=UGsCfVV<Lf2HL*T4-g2bT
zPUPZHi+$XMBtC4zxY)NP!x~bcEUZpz;MtV9TPh`UtpU%2Rx6_Sc#i$$$p<(^e*`0K
z3g7T^kV|YhidoK*suE4%eKz+jQ4-1A>s;|=nbBEUo}1o{D8ENCz+D6y-!!=u<Q5b0
zgWsFwFSpF<lp@w{1?!V%W>oM1ilVZDk7;_G492s<wzhmnZrWVfw+;ise<*CM$9C~>
z3nA?2o%~~a&_Zo$E*J#R4y?{$tj@2-wBs5$vq#n}U^`8ef7%OZLXvx7#k=+snsZ^z
zhuqqiL;QCK|MRQ7qvaV`{TjACMOdRrPHU?#@sKG&OFk5nBJri=uIn%iVp1p4?c4Yg
zuF-3t4fMB+9a~}8e*D5TgYemlog;`9I*^~{Iko*VpwfyLU2cB-WSf2GByYRh6(VbP
ztyGaHaht8-R;vrWT_r&D1D$=Eude*^gxlmYgs-1(ugg51m9^8+cWBcs3MF<DcH)cs
z$!>c;6KS&F5DpUKZ?MV=FmZKm2%q_yF5T<ZyL3K@DbzQ>op#F}>mg?MK+sHXW2>**
zX77G=uG`jtJkGv1%!lA`28M;BUDsXq_Qxn7Bhj($Ie0t|P8n=gL&3Xe=g`1be6hk;
zZO`w>CzC|7dZY5oy?yfHE!IBONij@>gG0A+SH=ZYk88%>PwBpoA_*vigWziDXOS@7
z40v^7phRK@%HjF101I;ISa)$N?2LYQ<n{xr*mUw%`0rIF_9KIqE0K){vmJDi|F{OL
z;KY>9QAMIzsV{l{GeG~jPuB+#0-wjeZ%Sg=`yHC@Di<OmtFhqQ!s>;LYzU=dAA5$?
zemDHpCtDj>_50^`%f<qivfX|0FL~Y~k2{{0zHBYS-d_Gx|FlPJmfu95gNgV!n8YEJ
z=iG`fIJf`#(h-oYFmq+yx2@m>i4+L+e8I`^tm$F#kKI%nK7Y;IwFprYw0x9hzXH)w
z<qDAwY7hz5<9+mIK+ef7VCiBm@+~9QLWp>d91@|yB&$n^(&BJ$eeLCJ)eB)r!?)tB
z=LrD{{%r4gTWvr$%BhFXUPkUJbRc*y!KhIY6})(1XY4%0ZnEPp`l+tppK*rl&w$Cp
z+krKaVuMJsv&%8#Zbiz+v`S>k&0P<!1>gb~CWJPZ8d6~fBD<&x9q$^y^?CY{`Xc9h
zmCb9;3ri(sYwDvMxgHt7Y`rI5b9D8NGr<$5LodCB>!OyKr0(IDey^&KEo!xpk7NP!
zk1Yp>O1SU#b64!O*2cE?D_4^#vGqB%p9XS}={)v$8kknDV3r`LdSEC|Yi)>jA<8y=
z$=3yd_gwEBd@l|3DB<D8as-kz%UZh^L?CHx{P0?x_?RyS<(VQ1lQv+wX=p4v&a?De
zh!ty=kkV&v1@p~#e;<c)7LO`&=VMaZFHP^0DH7|{B%^0e4~^Ii>qmy9Hru~}#lXT{
zJeXtf_Ey>>-l(VzU7MaS#)osjGEc2P&<u5}OG|;<TEDN8x$OhDLCRYEn)A^(^n#*e
z@dca*vu5%SiX%~w$xo8p%|*++#3BwU=JP-SyfT9$P`dK;9&7Ci9NK9xx48f5g!}WN
zUk?EONl1SX`QK?!Z@M67R~kvwm@@AHDVisBWRMSCyv4OMMnUaMJ)K=KQH)fv`TGD$
z2MAtuyv}B^cx#6P`3lZ-X6ogd^><X1&3?}+*3S*?3G_^HRt2&q?0AOh6jcKX-NH#i
zeaI6R%opTzVDy4Ywt_3w^;<2W0j925er*_7+9s_tevefckzJ!YcK0%sKxvQc1ubhb
zAnX;o?(;X|rQu{-6U}9k`FO>-RktH<&jt(vxxKw#b&x%hiLFGX3aFAI`v4pQwz7TE
zs=}xa=ubv@ytEN~5QhVsfJuM$Q$2Ty7@RZH=`nNki<Ht_GNt$ygN1LdfUon(?97rw
z-%l<23N_QpjE~U%MyP(^k*HLYJUb)sy$UB~=SBC;Bs}exve4%q32y=_FW!XjnCx**
zJ|Su7YA7=J808jE2%1~VKB%OXOGHJT@_6uI<8B%aCNvsv1%_p>WFF~P{w>CRsY`C^
zdkabvKHDwN+qsFVvxaXiDVTKdSmb*8ztqN?PS>5HNN>Wvo%fnBSK_9w8lC$xtoCX5
z>kMT(%I{|<U8l;Yze=5YL1D0cCf(#y-)Qd$TrE5E9C|fLPb$1z!Q-9m$=+Ae5>nnM
z-Fy`125W8g4f0Dt!6Q?{zIo}YZj~zPqe{wChj|K0>3bk5xg@QYtHxZWZET++H{v5i
z!lh$ag8EwloRtEO!4oB+E*hBpQ0PY}(~m^7|1>^WiYK!@OD2*$n6@Q^pue0mHQF9_
zvPgM{<#wA>McFY5PLZCQrLroda=?r@^>f5@8~e)Zs^~Nvzp(beo%H-XW>d(2UI09!
zx!_2oXa=bRy|Wgx1AEFRXR+nQ%Nwgy&+**mvuTUE@oPn!Hz%kj_bPw9J-Kqn;}p%U
z$^=EDNZBPLfh}Tt98*CIv9ZDwXT5^&k}K!7pG7X(Y_1W1aNupeNn7K==5LFxLw?#{
z>}@PYj4Alcdl*&U;zOW@`d=)TTJ598aqN}xvw_o~fZ`06|8o&W&uU8FWi#$6{#&2X
zrXETrOgXEjtG$7<+WI!{WzR3HS&oh8)~)_9z4Gs$&=4*IS<@_N1FyK;3Vf7}Ld#TX
z>rS}t3Uqoc_H8q5et${U*W*j$YTD>)u+mbBz3-Kjp&JKbKVwui>a&&Kx)dq4O9tT=
z;0B=jbJT4o)q9{lrTEX~rzbvMYd0_>v3(S<caV>?lX6!?eFc?|)5k5VEtI^~Qk>hZ
zx6bA${ULg=p4DGKVeNZDOwZcOUX&k*KYhbe-dB8HR#0^LRLSYU)SvEyk02`=fZzAK
zWd905TRZm{6OrP*qS<s!V<HLPon-Hx-k!Ul%O@E`oa`1WXSdO9+?J_|Og>twSAtlr
ztot`ArPx_OU}0bbm^?0kz}_eOs6DC;pa+G@<F8!rc4ocea(^y+k(2)IBZ2tOK51Mg
zaZXuDoqbB=FmjN?;qaw8(vv2677jGtLYvmLvN0I>e#^Q}v?9IgegU#Vfd3^qvshFq
z%c@%wY;l5mZgLk8P~UEU4o)quoc=CXPxil^dXV{?x*-iwA&%d1=h9Vd_bC)jJv6wF
z{C)$?aQMXmg@_1~1U+Q<#HGJdWGW{YZ3CPCr5t{Gd9`3m>u%eSI=LWF%Jr@~U&oxq
zl;Xbp4=bEY)WtFO1w7Hyxz=q}N2?;#>@E==cHy7%mjX7+Pkngj^KQG4x}AhE`gNV|
zA><6Fi#fOtB%q<J*Dd|G>nd2<jZkM#sFYN`k!YL@&)ttll55`aE8?Q|SH3r;{yiL{
z6W$&0M6N(>%IL7AgbhN$Ddp<`Ju8^nr;3xJu<UtkLcY9xy1nJV{aiiIRfwfoe6r?s
zk!er|uhjP?%&9WCzb&xq9Utj3`7Nw^6L8V5N`bZNUsDBgh8J9Z)uQ3fMuo1*TuDp!
zPwGU+ARlee8n7o%g>#W%j;A3%x6(N2*eb(6Z@*b3%Ncz97Q;s?=DBn)7OMHkY7o8O
z*}FY`bS!swk8)ehdMK^czZBdS64-xsU3)SgQR`VL5>j}3x6q+ACKb{H*N}q5ymH>2
z{3;~~y}+8+8)Fu#8~=l(37IQ-ix(}NjJcH<{JhOl?)>FBXNXed?mY;Uz)~F;sh$p|
zx<AheW_7Al>xhnxW9pVFF(|AFgM|!^Wepw?NKFdaks;_B!;HJMGcSaEOG=60&0bp(
zA(Cs*EbN&C1sbhmrLq0UYl_7yMRy9r0};l*|0>Y|B%|p5Au6pD+#8kijjs?mT*p=n
z0<#T=yT`9MW~y=29H8=p4EwmJTe;6Wp1|r&q>#U95pA2^dcAED+vmF?QOjYb5X-UW
zs_+z0xZfAi!ywvQ$xI<K<!8tC1D!yhEXWK0m+ulFzDw|`_?X#8G`JV@X`#Wh17CHC
zJL!T23mBv3<f*QZlLOZ+<(;aY*->d|3r&79Hh3??M0LAu(fp!aBlypvEy$MgF(6vR
z(5jVMe-0bxsem=huZX;*$axfemF`58X@2Fq1bX%7pni_`_I`W5+#Yx+^xocGXWIdH
zw5`uBT6gi(NdnXgH_SK*tM+Dii%h5#DJNTQ-?{n!{HGreTlXqi8pBC?wQuV^vtjt1
zev0c|!MoPCy(G0L{qPY@Kq$m$wePdGpIA$1wkOL2e;3y*q1p7}K%W5hY#=K$xSI>}
z#Iq|UUvvB&E^5g<B8=j3+1G~4Zl8m?iL3K``)+D+RMfAPvB!nc!>#USyO$cWg-;Nx
z&kT-dP0vPao|Q8XmT)Dm3RV2KlbFohOr|Il!Z}IY6soQ~gwtOUT1y?%T6OjRSs63r
zTQW-L>}s6Q)bra?KGb;||DjvB;h8y_pk@M<mPlmfxWb|UKcY4!yH<PNmQhlQd*7_e
zurE9mEasDOhD@>GV43DhE1jcCn$7+r_1tA=Y;UhwR2;Yv^WIEE&URrqOwI9&EB<#b
zldqk$lIg|5HRAv(UX^IIE<>hy(g3UIaYuh98ihxquk4T{$MpG`-N^=#h_0in`x$<l
zubYkyjS|_7<YF<xB^W=+HZD>^3e6rhSZ{`bLs^|E`NS0`e12PlD@%}!fu@~N%_$aR
zhr&UtL^BX(Z|m7buD9aK$Z;Q6SOJ`puO;PVnBs@iSHxZ1aAoNQn*(rV@1AP4AdP!{
zQvd(Ivj5M|Oa$07nCLc0pRa%|;`qt=gNQT<c~lM?JBK}hGaoc<_?`>3GL8Dku<o;j
z+h-1>8;y`pm^4s>+7ei>&Qb<WSMv>Y`HcuyzPk)hP}mOOJqPDR?U14qz962|?W0#v
zt}*awIiPi22JQEH$wNOoeo?((b@Y-h!rssdu)x{lqg<rxe1umu;ekn5GXQvtoYr_H
zDk!#^H1*?iE+KUp!?coh_~K-zRwXKVjxTRhK0nmD2Vjw>2HH+a)eC=DKGIzGS+`D2
z0L2l1X1vVGqm~|4P!Ae*-UBkZ{Q3)NP%iH9+Ug!kCu0{H!&5>q2&1*rG1pC^?o){%
z`4+MI*7T5WiV>^tSd{p#t)>3YPrfBcqB!1#zc!~-Z2lju2cgd*ctTrNav#<@x1g%1
zCp{<wbIXlT$NH=D^p-@x66N`6#bm!=0EC<1N7JjtYq!FVX=W>|i#Ujy)#udLp_s^2
z=|(6}x0U!w6U4CzBx@E58^4f99`w%FZtYwr-XPv70Y&ln61#n9UedA&ZuTC-$Yzv~
zARb;RemKgg9FM;)kwei4F17e6_P)Tn?~U2)Cs6^E*L9_9TfUZ(vbbK3&^v*t>RPov
z!9G4DkoI$6TF<?7>n%qHK*R?{73!+1$X}icz8*qVcNIhUG*&H^6`{v1hy<ss8IwAj
z%o7$^>+XW#o2G;0=tN388#}`NyiQ~z-1MJ*J;>K)x!Xea@YnG}q3EIJ47T2XgFMP}
ztNJ<;22~+On3X(TLM9PvZ2Gzq1v&}UkC1-h^tOp$uIO{W3rfMD!>!rcEMJZBFh@Wi
z9Qq-sSE$bxVF^Ru)h?A`=cf;}1LXGoAs{wlmxX_?n}l^wX`ID!sYvD->OP1t2(g!q
zXVYrfA#Pd4TWlK1LJgD;W{XTO_<j5ZIgtc@ZvT%31Uuo35S+SOZjx)Hk1TO*1RcaU
zpAT=RL?v`0ahNKaE;iV90Y6wDf3oHAsHa_fPfV|h<f@(2$-&k)TYlDl=;RuS6O=e#
z6Y%b`ZqOqAsACp!x>rn@lBX1H&Kb4qPJqqmd8boJC}!UZqfVG4rXlrzgdS~Q<XZSu
zaXV53j5?2!9s9m$@=q=Lmf7FFL)^-j7;tojpmU-hNRSLRe{>4=T23lYdV%*MC;WX^
zq`;fcAC`qNmX-zd+AiB(e5(Yv8}b&^qpWcjkCeL^HsUQ&p$}h_@PnApaGvgqfVweD
z%CPuLebbHbxR_k!z|<xOvu%oqd}2&0xV#dAw}6F=e5uYD!T}&39pVY(YE83A6b`vS
zu73%7w(<P(SD;Ia7YXh^!rd^qE(;wm)L#oc{=h*c4^*(jft16u(w&uOdCmQPMaH~Y
zsmOXmf);@Z6`kaX4RPAPKZrPDcEmRD-Onvb6Y+xH4O3eQC~2g&80+_g=ApA1?cokD
z{|z0xt#my$O_L2~z6kWg!}cjv&Ag^JUQEW0*)lmzkP($);3FiSxY|PEuKYp0z<$9q
zm^f(T{|<weSFWn(kFBQCN2FM4KWM@#O3}fY7ZTlc#+8<Vo?4ja1okkda8>0&C`B0J
zNFToORlfYLE}O)9!eW%RR_aKr{)N$xfB*9=qLdrW!9Y#qZ@m^fNs}P&>}ESw+K=Ne
z%hl%9PfOKbb%#gne}JslwC}WiL^PMm_Tm!+0bBUcESj3}p)R1sy`wrq9ssc41c=l%
zlzj=MJ5I}4d9GRQVJAusz9E~L9)YmoS@#x&OZ_8NkDc+`8B#aM!5s%Pt1<)<xe4X=
zS8%*<?2;M(z~??nkj1)x*y0o8TO5=Sg9aBGSrL+Uu+y87PS%T;cL-LA7;QMt0uy>Y
z#y;~e@~BuC*iEzhW3eEr=C7kWH`xZevRZKPxyUb6mW_nJ$=uj}d?Z2OUH;?#MlpDP
z@vQ+56{6$yb5g{B>$|a08|RK+{wYJuXvDVT2XQbt_~{g&UQ<A?chdz5-!Es&O#B0-
zfsnBSv?ty;6N3GF&j>Esc9IyqLwF_C+ydvW39%?JwR%r+O(u(rFd7DuX5GD}UTcMG
z`8n`izq3}e&PdUBkmiDljALk?H;hy-w3yAp<XL>ja(m~iT*%O!-kO1}KzF+Tv=m)_
zOOa!9Myx|v{x-a93;lFZUD^KSFnw}V;(deK#kIa|a<op$1pw;S?c2GZWs*x2N6;=(
z=zb~zK3xJ>dB-|fKNsfa-1_E|9Q;exw)_r>_xHC{Zp)wYg@Bt!jnC$8@0q~tHhU0L
z1_$UWL7-(HiNACJh7f(?FG)(LDhT!01wg<yV_#kHcnH(8bKB}%Jr3P^pm$*$DqHD4
zWzUt7IuhEYBiJDI#$!p89VSmgd{01i(F8ffIu&7moTaIG$s-H**D`B%61dN_Sv0p1
zIM?86r5C&jfK&3Bb3fy>{nW~liZ%f*QvP-}P-kh`bVKdrjK_Hq{jW1j?a{f5dY6Qj
z<Q|Tf8T{h&DEP};&~zvZC3e-$0&%ErqiN0@8L{Tgyx@UQ>q!>7_$p_;u!^G*(DCAU
z5p@Cb9}8x#A#t9LT1%au-lbvJM4%Ymfx;krZ*E3tO&d9GQ9jzX0%9mS_oYWq6cLg<
z>$rj*8Ijn^=$#Hv4pdAEkM=1~)x8NsAKdb-84`;i!(9Wu5t-1<CEgBCd3;~ZS#s!e
zm7AoGOaqZB1i#XSx5pU-;LWn!Rr?46zOV7F?I!pROL#5wxs(Stb+Q{OjT@f%rePQ~
zoWakn(ouEPO~W=M)px3nSD<{iG1#u3cy}x%?_<E11(OeMo{O#d<o?Gsz$I<v4)dwn
z;*M{DveO<;F~26!Ilf|Ws$yuTJ5Fes=+_V>J~M#{*+)M2)Bv=&31UA%wHz8eUj0`d
zv}ca)^dPXCC6HqXIvTOgk{!PgtoQmyrp1RAm~)f##O40FD5Fr1V=|lZ!T?xmd0`Tc
z;2>Ro_Ty9Dmmpb|_BlOI^pa^!WbH`SS2z+71l~EQY<tyuJXTPH>44CL!bj^xJPn-6
zS>wzdqb_%j5_DzPwr4TEEB3E?Ng$4Xy79dw-zIZ`{#k%br8s<*xpO^9Z^cWPTdl)p
zF7cKe?fWRGyutB}qa%gH;Qvq>kn0$bV4(!l|2xTzt~7qn6RN$oE1^Q@O#ou;041C<
zq%<p+iPtlkrMUESFC?!WW1cHG6KXc<d8Xalh!p89KoA@JP0k#j9v2kWJJdexgG7sn
zq@Q^9fAIg20t!?Alfj}?7!Lj?d-A*;4d<B;&%!>?NNn?7Kz+YoPc~thkt!Q*h>TgP
zH&BH3zPlm+=kfM;yN@0w@`1NzdI@BiD8p^ghP?+@^~GKLnvH4CD2eDR?pk6PQLeRH
zKM~_In9Kxnux}N}-J;GtO&J)1N#AQOYD<WYS!1{bM*~xJ`#?ZbSx2I~+*GIpbBRd0
z;Hp&Lho{t-D25RUeO5OmS@Uv1)6@kG*)JyPic`PhTJ*cpgW7Kj&kNo>t&C_i6`7H=
zgz`8Y#muB*ZeKij(j3j%cSSM-xJtNb;OkvS^iI@?j}L=QzURsvz0HxmQtpPts~1`A
zcuN%VD1jn4e9jo3g#O|+Gzd0;&E1E5q2}yX*AO#3^&M<GHX0u@X0RN{?UWeou!N9S
zVsub7(?aZS9&0b}ytdEi7S)o`g;_vZI1&;|D?%swvPBGGfxpson<0}2f?9eUi7ki`
z+2YmhFpi2pm!RM`2luZM*5(#g5shh1m512xKVKS7EDmI9a_Y{D2>UT^n%=Fy$U=-a
zozo93E_sBL@=E0MjfwM~4@O1A9~|eEypF+EbZ(l;L4&Yqd%+jn$0I=cZd%1Q0|7ac
z8Oelio+6I4<^A&7H}0brHy#0h<$jmzyt32iDm9o!gSJx8DF}wA!F41>*PHQXF(5m|
zhtF|B4d{ZWc5CTU$8U7}Aja=qvUoEoGb&2uM2lkA=W{mYKRTA%Nj#bNn=y@Iu4P1y
ze<IXkAyYW+;yr`A3?yzdV`gO-;vvv$PRn$zx9=Q)LA8AUHA02Z{(4}|Xri8Lu=xDD
zm02%kz=(W7%p<M$rj$+}!iD>Md77H4$u<Kp*%Z3p7;23vC>a0KxNw)FU(RA}9rf&O
z*PTYD+<hG#rZ~=Ta6J%RT`fT<Pou5ysf^vTg!vmR=Ic~j7;|Gu19Jc9(S;+Y$rL9E
zz?f^F5$P0>>9p7Xb3@TgHAW<Nr`MW@-927wZ9&cu7`h4!Fz%mcvx0awLcESWgtT8w
z^iYYIKdF*TQ5{6qi#Ju_rUfY4PQ$)5U47nq%rt>%h}-MxV9l{!RvgnF%~O`pkC}H?
zYLe=-v+rCLG9lPvt#=_oK=_o1=!hiN2AOMGKyar61|<@6nd3i!#vSifjK10WOv2@d
z36FdGLh!j`1AyrJ?H}w4`9dZB!|Gq^(hHZB$=VHGN%P;5Dn*aWVtpMc|B46DyRx@#
zplrmO;`)Q~&(lZZg3Id(bS-f`=w_KYaE(v`G>d(qz&*>J6p6<9@s{cy%Ege;-L}x(
z0MDNN?78$W-i#yRzp%HCZ3{{=GKG^<@{Yv`qpT>B$kUTf5$<5QK2*9anKl!tjfOJc
zea^*%n)@{VAnIyujsT`8NgsxyPr3gJvH9lj3vX?`ls$tX93AsT9uN#({wX8%C{lVT
z_)w!S;fk`#!#sv2WU5QJ-KA=9hu|ZlEx}8V>-1Yn{g=#bYGA8CKas`CKs-=9QUTKw
zC-)bb`eoi(WAvl*ub+Cxs1Tnzj${Ih2IQ#(&k)rBiS_@y6+Ew7SuFUUSZ3<FjijZ{
zds@+Hk?s_VlQ|5@3DNDrt$Ozf>EFD}8F@XTb*=cdC?-LyNFpu8#EAJnZv?x!K2fi<
zA(1}j8U5b}*<-cz_BG{PQQZcgMx|n~kh>#Gfg@+1iwvDtbt}>nvZM|?HXb`gCgjRB
z^7I>cgD80I4{_*XK%n}u%fB7J*g$Prvb!q+OkX<I0hLc|KYOGl0SzgidivxU*;q*M
zTq{^Bb&2KRp3$OVa7yQSi^D)`v2qy99;lH<dDzqmEr%9^^!H&sOuX_EJB|#j2w6f1
z+NJ0kk$$+;h1}0LPl~O@o(h(xCuOl((ZsRUyMMQY^&KYVB0~g#nmE5V=-aU+JYOum
z7HNce$%5Td)%cPNMq2oiTfl!O>P6h*J|X#x=hy=qsxLmo8)h=yNL@6VGYbi6J^MJC
z>t-Q8%Ey!PlKJH<J0FJqBWKPe*9Zw}8LG(ruo42SMXKhfZnaPON(kKRaxltH|A+?B
z#u@I0$XUu9ucMBtk-!GWWb^=%7bYDu>cqebB|jgc{#6^pnJG)_{oISfmVGUGE3QK8
zf{`4WufgbgI*6>;R%AJ%vhn%}x)3Jw_IX$ON#Ik1NvU+fo%xQIuBTYogGPm98F?kY
z(sKI%oFa8KugX6^3f$XdyY9>~p&v3>mvv0UEm0$LKB-Q^!ocm2-y$+emafc*wEhT%
z)VZ7hAVF6~VAYq%u?Gh4?5jDp5<BFq(N!{qE2ZVo_m+ao?bk5glP~!?L2O?TX~bo^
z0rBE)N?6txe{noI-AGFsE#n6QPW|eSps|{+L`$2mVILuhpPlB#RsWN;svYEH`=3OX
zrAGYMy+Tkin}7q=?S}=i8T%yct<UBHAi~r2r<#K4L4t3D%#p537;&7|a((?$2T6Im
zOg-C~f0Xr^WSJF8et#S-J5H}6oD}Bx;)=4QUMvMYcvM&DJRv<tJzY5;R57aPpI!_%
zDUvwrl$4!0NuvUBv01EZ;mF>u^u9nkV%mj;bsboUUWADs2Qr8z@)c<%^+wn^(i}YS
z&Y}*0tr?SN4@AadJa!xx`iINZ#6IPkr*w!FiCD6KsHWETod=;iThV3(raFB$`Yz5z
zr&sNM+1H>#7@Sa3@mA>7U7GYbL8AX76CajgBegAxv|9gAUy64YP@w{nKa>Eb><<ui
zZOs>b#?6(}<IZMDC3dfIA$&4RtzkYY^<TIc<%_%iPq>JHkx81mN6oZNjX$ygPJZGS
za5F4d)`^0dp-UqQfP&!NH{Gf#*?nqv(f@Czh@Em&vZ>UCs3?t2gr=*~Cb4m!2t<yf
zA9FyZ?Rv1d7m$_OqDZp4{ZEU??7Vw=Blx&x;c4)Pxtsi#2pz0TMnx2gDmVADGJz*B
z9EDdxld#~<^Eeo!B{r+R!C^`GubwI+oPOizcm#Z;_<crFo3LMv<&V!2*oY^wQ}jMr
zqE`D3_YeM<aclkInB((@iH(#nA}5w^p!BklqJ0@OK_w~E7}UK9^ATVH>6DQQPF7*z
zQ|WRLL`!vA5!A=@7rRCS+7ORp786$JLst>LLoURG|Gz~pg8I0_RrJi#ymI?xxqy-o
zF#!M78~kC1bB1c9BNy$Idck*Mx>2b$@-&72UIxA$cQ3&G%zBKtLBDxM-HVE&e=CD`
zUj&U*{a8I{Jqq+hZXy_W5dgb^$(IEf1&5!64cZryqKHq3pMzB7I$)U>F2BIXsOzKr
zUZ9D`D`p`Dk`Q|bVP)#xfnD7B2?D-R*8Ci}BttRSL&aGWf3lq!^QGr88)VjS1zn+J
z*#XB@!6CWQhBuO<8kY0lO?;z-VLK1WgSZNGSr?E%ond`I_>nV>#-!#%rE;vsZZlU1
zN%(~37nHh*z57e_qlI{1;OOLg3zi1XPp{07$B_=q7r3Kg@=FA%ng4<mC>W&EpNUbC
zioTy7Z6-&F?D^J2EB9NC%*4nWVKVwLPf(;$9kD${*X{h`POuwJ%pnwCiPSmzCyXx=
zjwv=85Deb#?~G#w!nK4AbQY_Nh)#{!$J&Xpd;dl!KUKEX6w39am@k)RKOO4@_mySC
zV6-*e-C?ovM#dDZ$CWZ$(e78BU&c~YtT#ec#=v+{l-0+UjU8G-e895{y{bPxl|5{~
z287xnUDf3u&yPGi!d;l_z{leCaT&0)5@B72CU=yTfw}UN><f6YN4x201G^t9ObN><
zoYp58Qg`>Kmt*+xJ)$XEnrKHa6lX)vaG@{a-IYs+KxnESf#!ms1-2&Tp67sVNfOxa
zQZ|+_e0SW~XcKB*{Qq>a6Cbi~4lt4_`x!}+b_EO_yUirl77_M@Z;8GlV*?<YioB!2
zhUhta&Z66uJ|9>+>7*^_E$vZ}Q?r`>JJ)%PH!k<YDIXjI(M<)XI1Gj?(eNYPCzvO}
zyL&zh<w7JCe|Q6AoOK3&#@9>1J#PZxF)k4(k?i%fv2f1UH<0{9B{;;`6+>WGy`?Ma
zuCTnj5F>Jw@LbohKRVsT$+(Fg*p<j_xwhho&BvUuNK$3o<r$ITzYyxo!eQK^-z8I(
z^$V5~vR_rlU`<oV#<m>G05OE~=e5Wzx~QV_E=kfBenGhhI5XlMzLqzrJqvM(0l50&
z&Gd=mh^WCVtwD7%<v2xbcpK3Z9jGS@w<a^uDYH6&GX8Cj1#hXfN$kRGsBZgbKM)o`
z$;@}?)Xia_l0_U1R4PFhF~)6_<qZDXBxyl1o@O__5V|A|Pw5#gkAwiEd17)}?g6AN
zf`X#oU!GrWru!YIXOtggmfo;^*31=m8J}-qxg10bE8Vi%b{EnjH0AtMV#&9ZlnQ5I
zHYddMmXMM)b{;=6JaY>2EYW6$10Kp<8Fw=V<JarGkDhYw%shT^;0ns2XK#ooVxPto
zLQGhKsKW1WD6LetD@yjKg8ODhWIiNVj(YcRJC|-SA_UOhiu!1t{*0B7AHaoh-FkH|
zCd>Ukv)Xx*NZ7a9G-PPY#xfo`s}fdc^R~B(R9qgV!R7W=dK2(d3?RE$nSAmue<AX{
z_ki@RHSDWqzAg3GhjFNJl37p{PrLPqPaATtAgm;YX9)WQ3Qe$a>aNEkw#-;#Rh8Fj
zs{mHeH=Ce~VveT6n-|jnLMMI8_B%S+yI;pXq)#@XASHMIJNIHJVf(|2RTgvMr{a5!
zza6#gr}x1JWYoB4j-OCRI0O#j47fsM{YMrf(Z~g8x8?K0kFjScl-=<$Un-8~pc&Qc
z`O_hyOAmZe4|6ax^P!!0z#Pu2R)^rU;b4BnG(OMnvVp@2wF~FBJK3j1U|}Bj+@$?O
z(dv|`-u=-4g;O|}DYCpzhJDoPiH&3<Hv+Y7SrP5&wKe88MI<xMbw(FC-Rcr|T(5}Z
znkY^w7=ReqRU$oK|4>Xu`t!AwFwKhE2#Uyxfo~XK$#eIugt5xry+u54B<dEbXmqKx
znaLbABqNRJX*LztCkEAy23SnzVoBUie=>PdlVU!7{zAqv%_UY-Rs%!3@2%-bH1z9a
zzPJ>QY|0sug3*Y(>y!4V1s@uobLs#1uwcE)@$-@M27Z&%*CE+Y*<SM~_9*Y1{;9u3
zuf;sRdi{LW<~dj+vVXagHqskguRAN`eq7KEx^w2$$w$6z8s~L*|ETUsd}3Z<BiMP7
zsqnZAG@m<9c7d8(c_5C}O7N4u`lyx2rsRY;d2dwfuXKjxs-DSQ+RH%R7RHS^o{^sY
zmbti*{P8B?U5k`?+hKOG^QcHC8}$R>K|5P_03$+vN!spr$Lg~k9F$U0U*TI6f0Hn<
zoU$Ak?Q1?F?!>wCgbFsfY$HQ(oZudQw!ZV3upw#~+Mr9NH9Px8UzHd~DpW7`?cSi}
zQDeePci>A9m{MEOgqrxVj2zRsV}}SMQlB_r6WuO67YW&>_PbMj%a=t|+I!j;oX^fc
zsEhu5`tm~wf9$yve_WvxGImwE15%zqFbL$ejtf;nLReGHQ?rIjW3Xzj5i)9G?(~|m
z5X>2$isg_a$2?uVNYSE<N*k0lOesf8^4F9yO3OQNGmh!092&-6yPY!1y>w>GJi^$X
zy2AW0lmjLai%-FtLjO;jMntyu{xKKe(~FGK5?ZcH9Q1iZ?*D9e=Q3`W_oHnTDfA)6
zUlTIWiITlYpd1|!ZW|L6oZfZI>rvRuy}nyl)<5e%GCh(FGdhbDmhO-8oTG}nwsS=p
z`!R>)lq?%Sp7e?<(-hCt``Tyc`&{-CcjAi7_yJjop(m3w=&0)3?QkQ;0|;`-wHK-(
z_j;dvNpow#AI^=MQZsK(@X^}ls^4?&j*7vB%Vk2T(0oSS!}xdEwO1}`cFKQ21JIHF
z1GUn`kF3z&yP<3rUzWYy6Yz`vyZ4fQJ_Eb@J|BZ8N6FyNha6GHeV?6fc07CIk+yuR
z?O)gDzm$ceYEYE(eD!=T8&D}f{3c=#ZnAQAST|td%KS}s4950eOUD|uKFn9>A@odL
zp%;)?Zbkb-%y9E2jhbt>M|Zlf7|3y?(uje9*@NEGA~*Ghl$6vj!dI>orknXsx-d&6
z;8SI|?v@WKPDy21od#d|>_)d&MTCpASd0bLT!vmaAn<#0eIVRft$(rS7^A5pt+Bs^
zn=E6F2w!J!t|z<YeJR`bKg}(_d2<#=k>1;nNbJ_7(FUJEl;twaOS99TOdEiYXvd{Z
zeM*o`ADh9cSOVqMZtuaemII&@JDOCt|A;AW%;}m%K28qcp<OvdEUSCf*TAj5xEw8j
z*dIB!E+f-*=b;RQSyh5@y%l-E<PT$&wvH{M9T&3*M(|b;sSZhu1$E6l+c-WF_SdqD
z&pj3yY(jbvvfNwQbk~Klfm5hiUCOsyp1TbP)EeT5wA^)|EKH9Q1I1@4yl=9{Q#14o
zXDZQRXnpM_I(P|t6Y6q7vL|uJFYP%u(|K<n{&DyF%#)O<|AVIQ4y5vZ|K~Vzj5uZr
z*^&?n*&Mu$60-MJAv-I{44IKAGD69w5|M1#qU@Eu_g?+3r_cBIFV1m4_jBLZcwMjS
zby;m_OpQrIw0$xv`k9^{>QZ7tNVu>GT26VQHC~1HQY~-J0I_>y-f`$t%MMufrExK*
zon)ZNRA{qlePvSOE`L-F^M~pK;{j@Ww*)VIHBsM{0ik+OebVH0CqFOLaCel3R1Tk=
zCXn1j+eyQP^+49&n}h^JRwB2CLCU)P3gj#<(OcsWS2-O*4<)d4w#HjfwfhPcz4?R!
z2hm38-e2=-m>Ciqd>9-k;npQg3p={tHzYW`8i)hgU}JC;qQ|;k5BQ~L{oWjpawx~v
zxb&Xn9yS(xMrGM)Pb6j{4pFxpMl0|<rMv`<MC(d|5G@q~P;ns|id1}yO^--O=rbmm
zDn<zjcb`47FW(bi`k5K(d6)JEiCk?8i!0Nt8aE%v6X|2LM79sy;O%LOmICMKsW>e=
z&D&_nbW~@m)RG<OOk8B3ORMS_Wzw(}{E7+0Man9DpidRIgqVTfRO`pLi<1u=FD3Hm
zsLFI|jVnl41mivthrax-3h@uFMoT01`&qy9&EFFNCt4hYN}^n3?#uokU636t^_#N`
zphgyuP{HR7yMe1z!^n*E6PS&1srXiXISD&Wo&ULPBdGZQnM|DDtnAL!xzdjmPqTaS
zUloXE_<OJa`tO+GE2Jj^DgETrln1Fyul8T<0bjb$om`g?(N3?)ac0FRATidw^I2iN
z)ed$BqRseoPp29?;e<g-6>4~^W)EK9G0~vZhGa0(lXR9z{Fks*6InliKO^cAwnl_<
z0YOlBm)3)`yS-)(M3P3q->8Ml+#r2FGQlQ8zg6tF`avATi26Zmr@^xCX+$yg^#G`S
zYyWj@IgENFxoLS{l1=X7l=@hV$7G1eXxlb#%%kkmZV@QZlz0j3oqq8tJ;D%rR;PZ~
z@_TOiyFp52^!v@Ku(yvU*KU|y18u2(sFfQ-BH_BR?#p41oiMFl-I#hnM~;ZPTclT}
z*K7$XNmTre9;AZ_AN!R65M4M|BzMhaQlTF#q2<DY&2ky{$D;jBPsNas>Bk4$UEb6*
z&_}c|`FV8m=J8|qzkGmCj64M9{62rP%T;vMH}1zUu(TmTQl?7642DWf96lR%fYcq^
z6+9x=nX3Yn#yCDwpViE#Ue`(g@;R$+?n?ae<bv@A8_)c`bqWlBuOC^ko@p6_3}ryV
zuh<kHY<E6w15|6ypLQdyR-)Zn8Uj|qfiz_M0j%)3Ge$N9qL6CyuQomef!9%w-=f--
zG}bBl`EeW5p-R7JUvK+rUM36ylE&A~zs!&HP){1St7A?=V=>{}1w1zmN)-*-;<Dc=
z^eGJbz2I%RQ-;0#=mn=LLrAG@xWnbrs~^JH2K@}|Pv^u=?}}d=uh{Dxk=X0ptx8kx
z7=bVK9@~;~o0Xh<JnplzTxL(^+%VZ=aQ97u+uPidDM3*bSBC!^IeMi}BcNwMK5|8l
z8<~fw`L2+ZPE#QI)nWhKu*1iw5Q@X{XBF53$Xl8}zph>qhUU{yi72pZjjn&LpUd#~
zw1o<+q!nwyx80#uQI8AT(?%JBYBzvE(mXDK3S!qUr;FFf2@XO1cq}zLkwZ*aUf&QH
z?%gFRGvQB=4;`gTcFnU%TsZu6KNz)2ZePi9CT_1+tO`RYv#JAg)&I<A!X%naEymts
z8PqK9auY-ESx7hKnFjt-;WqC*Ka%y@DpuO5J3WB5`G)d+Hkxf_vM|OdiD&@G3#t<q
z*{jt%Jf_x~KE2+wll*a}_X2aDu0a^ne2Ai9;d2e;2(H2C1~yq7t7&d89m%7$Z(nwx
zNFc^D$3^qDSi`@Ky?4C&fXy?_sbc1(&d|g?jc0yYQ5ybs>-buLJUuG)*d4t4{y!^6
z9R9odRsZ7E)BGp(Cj*d=Xay;9GQ1@wM60<apAVAlrk~O$#??N^D0W}C)6DkVfO${s
zxD;9<9OFcA`1`o4w&_ykKkCT;-XLDI+NIRzuAvP%3hKX=+0}1o&u8-)`+nEDfPV;w
zA7KSkjUOe<CI{oR=}4UOY^viQ{@oC-`^tYCzDdq%DOI$=1z)HCb5drq2253ZxdZJ^
zbnPV8DGOg|Nxck)thKS}DB|lG&M;Nds2DBENlr%sNl@ndn_NXD7&LcJvto}jHy*-3
z9mGje7Z5~NxTIu09i-SE4|n`%wrA(Oke61wQMJ`c`q8jGuMQKdks~m{8;vQaWXYKL
zk7H;YQaerCWz)}L1Q`gys`;kZ+#63_v^<EJC3NAo2&3G5kJ-x2hd85xQSMJo7>F)<
zr59|0*}N?CLZ$zGvWCEsut%Qx9r8B__dpj3<BhK!iO><N@SxWSi_3i=1e9WqB*^d&
zvD50>$ATKrRsmQyA46*kB2)feyRQFqCoC@z6P{%lA$)aMyH*}HjLU$`KKg4P%<uu<
z5Ff(yhF;0yjd>a2oacy(lJV>K3Lk`{Me?Nl-DVt|(q280Lz1u+_UIe9D0R?1iXr?W
zw0i3PTSw1Zm^04)J|_*H?Hz)aqXmp3&SIe0!tbKi{o9fo3QB1W^eP*nc-0*i+0&dZ
zEHps=Uh3v+V$tuIT4T(Lf5cmtatLp5%kFk#QFej`UaWIS=$cEE%q-KvNW2c?aV+U|
zQ3wC|z2Ro0YoM7CfLvSF{>VWcDts!E1chW9N_+~mGPjpMRqxI9slrRdH!L&qMkb>(
z(%Y0KaOkt{q#nu>@_O&<DNjjy`C*-(#)`4|51*Ob1uk$*b;1ug7Tphmk{Pg`jsc|M
z1!Y66O?V3%0a*lo6}?-Y&gcm}(<S_7RekRAAfcsA&!PL5y55)+4}s-)$haf9)qX8V
zv@B9R>y-wcLor$)oSC<$K9JSUg~+Dw@qM_#dic$wJN2D%ymj;LHzud(@jqPNkgp+|
zEw4Sp@ZwwGYC24s_aE7Hy&GVj63XO}lqvJaBx-|&JkA!bf#o^x9u#cqIk-=SsmCOf
zxeI;~?6W2>dML|hUK%l$>(<RYKmTIz*JWPeZ)4w`?=En4lw6TSJ}fsyI@$HBmsZa>
z!zp|59u<ia(?jj_vK0tv$s<eYy2Y{jg6g+$tg|GodQ!!Y2D~Fpz&f`7QPPkuw)Bk&
z#ziJf<r*^b(g*;*whaadezp6uc!^G7;_gUFJCu#QbpmNpv)^d=w<2?u?<Wd(^Z8B}
zf{wuRp=~xAyZ*ultQaT$S|w_alBAQv0HTXO5>omJ*sw&Tg!6P9@`Wa?_o#kw_WtEb
z4cEe}`$SFBjqi~GjlrizBOb#K_!<nu?u_uqXo!{zy#}F?PP>3u1zFiqaz+bU#c*bn
zrV;nNbfDspFUo93oG%)B0KBTFX)6;waB>7<kZ2Q~x{z}eEv2l@b0La4MZPUedjed^
zk2kX7Z@Z4n#Y|$uf<jQ+L!hi}57?;~1O63Lt-m)sE1g;ooX<O12Wa5=A_@V7S5byU
zp%;DbjXCWJ;Y`c&)o`ryBOjpSOhlw+{*C9@Wh1FqF5Z-3!5TH8ld!k;e=7m<Y8!49
znjsgZv6ZNzpA?Ar@6=qfgrMn|ppPIynoU3lMhE3Xg&ECr(XXq0mquJkN<d7`U_e;e
zRuDVlVM#?ILQ^6W9uZR4t1e@Ly|U+Mb^Ps}L8&aa?349JPOE_p*0k|`S>fk0*1P2?
zXdTWd)1DO8Q<mK3{=+hH@fz6an&>fvRqD_!HkUFrPgFb+9s!Tkt#4J*dHg8Sl_)<k
zB#?QD7P~%s`}RJ1*S@UCWuoL5(@=~1lVlZrc|gN=N*4xBoL2gW++xf(1*IEVIWRjP
zZzT%2oaHbpzSe>UZ|U@xW%ATEU`bYW0r@CCf8TK|!TVI7Tq(LgCQ{I#(Sy$|7@ChI
z@kjJP?Y0tAFIi{}0K}}SARrx+y!2e3f{bnU9nD0L8tV&dHY{<5e~rK)1*uXJH<xC+
z$V62N^?wR6O6fwLuR{FTYaIBWv^cgyC*eTNL1kNW@D8FNbGKvM8_SXrOO%o{>T1MY
zV`fv)xUz|nZaiu2GjdwlPriL^A(0j*w{#I*EOvTkBQI|&Y!eQJx%Wi#5Gvm7OG028
z;XL>7>ldYKm21*UX}Rc(ZUCE<UO|0%oA6wi@W;Pa8{GVHoH+a>E0-GM<q)$2*UnJ4
zg+V5H{61p8xy<5Sp(Cvf&>UE-S(=fr`J^!bQ@7jny8q6R{avt4t2scF)AEcx)6IEh
z|Kl@YqwyE+yD)iCc}zV`0Nj5t8C&uG^&^3iUQJac^ZD)!a^ow1Hh-*KY$`f>3%T2f
zW<M0q6Uk-6#jL|Mx;1Lm3eIz!02tBth3fJ3AR(fMOVeeu$Q(<mD8-jom|+*+?9P(%
z^92WvQzWJ{b&~zKKS?)z3=FT!`VKHVb}{&k*nLYgQq(yC{Cx5DCq6D@(i<I1Hz+KJ
zE)-w5Wr{|vj!J7bXka!i7EL)etOhmEyd_>7_Q5FGCqOmkMIZO9q0lIK*<y~cWDR-&
zbN@9vE4ISn$V}$8GvlxB-mn0x5r~dbFgN+gTyxf%5&5V9(wWZZc8MbpCk-edtxo7L
z4&OS#EWn84<JE%_hxKI9-jE=F6+=ZzdHk6p+C5{+hy%@=eHg;1Js7>k^kmqD1TJ*a
z8d$PokByHTxH(aX$d!hJzH<CLSf5v50k<v38!yL}wDu)OG|}d{hAc&3<!!eypBj83
zeHPz1-ghB5P(dOPR{S3CKJE)VDU?)K!-gCS70v=W0iy%>V8@tyKc?sI8BT|0*Llyq
zxf{UBEamfwuoO>%80tOtwKB=4_19wtI)c1N4;oB#0i2dHVPOp$1&ejJcBGTH{&8xT
z(}QZCtdlViX4#s2=hA?>%n8I58LCVc8uQi_y~2vw3rc2{K=nD1eqHWvz(JGF!TYxE
zY|uqfYz}=u#S}l7ddIC}lE99I-N_{FFX4W}Mjzb4aR#<$MoX;TP?GV2hIk%AoiW!^
zW$t^jt5sXKLvQm}E(<-*TULU!Y1GNDk;&f^Qu(bT?p_^C0C;a-_5)h<vB<b4aJ@H<
z?hW=VG$!-<8JSyrg9>Wd?MW)-v6xad9R6dH$8AM0eyi2-TB@Qcco_&;unm07ljTWM
zKOxCA6~}N+$LiqZ<dHaU_%H|NukQR{kC`_Lmv|kFnw^%*0?<l?d_JvM@*M{?cxcY~
z4#pIhi_`K0>Lrd_4_@GpdjeSccT>6=Bzs9`%U07vDp$&k#^y$XQGw*Nam;@Ea)iN8
zFY7^&%Sb?QriJBd70xDmMq0pakEv)}ljz1R(lLv&O!`D6^AXZUcEL5Pw>Hm)XEdwL
z+h^TwG;=gA8?i9;@)&@lmoBPY6%Q@^!*#WDl8XlTj#HIiS$?<sy=f$*8aF3Y){kt<
z1Za}*!nlBpV57Ttu$VknZUp_2xuNk6XIn68JG90pY$p35L4Pu+Ws$xedfW4rIE2M<
z0y}W0|6DUDtkLQaNoz}^pSgIu*AZXZznC`C@M(C4a)j&*WiKsSBv6shfQ!aos`|}O
z=IwEBM#Pm<!}~qyDKdWeTgT(k&sEiO!EK{29Ph6*%}`c1w>y2q%>kh{f`F}eMiV+7
znD$6coSRc{yrtZnOTnn(Cldigj2jwP{@^MY#YKq;^^MWb)kH^sT}+!8<p|r+iFHjX
zJH{yBxXaIJ$J=ET&%U-FdV=xN3|-mG0bW=1anKp2hG=yum!4+dRrD>hc;&TF4S~ve
z;0S9r+F5{JnJrc7Uq~#XEeja7!ovAE{V+80+(;;>b4speQrQK9jLY}RRk$ZY7!-<0
z8{7XjP^*(|dcEzjg;=1pIK3}jj=*ScfNv9gSL2-+t_-|urz~JlPPVlwqvpqf@fBmk
z5U=~e5)%S^sL>2kx2g?s&*n-2*x3yW{}pJmT;V=yVsMHioHn>b^NFfce2LdcX8lA8
zQmDsyyh?jqDZX1KMI;VogSH-zgW`-#4>k<TkyZNBZ(azkDy;afI2w%WJ_YG6Ev3Of
zZz(0e<WrMe5ZtpAm}PUJ6V1T8BJjO*t5ZVakfpl!ayI+Ks=S{icg^pY{pImX7cBjg
zzymvnFe#Y7aeNu%ZS(?%`(w5(sE01ede{pzhAS8g`fT!tgYalh+{g%@>V&;{)3gas
zW7BfWC)cQO0fICnd!&1gm&rsLF(}5x0Fq{3e2Rz?4d?!rZ&uhWOg0Z{UqEnYQd)iM
z_Ga!qjyY99{+J2Brh;+b?^~24ppig^?t`3($%dU@$uK0i?)&S;!go-T81e~y^c89h
zA|7_0)Fg5|`@m%$T&W+YYOjFj(1>hfUq*F_rdF(Vq{)nHYPwA|K%HQ%TyH)!StBgs
zrYIFj-t|zXlBN8Q(W6SBQ1x-q_QzdE(vWmVCI|)Zt@p+z*DXt8xtnG*Vb<PC_1wjX
zk?)kZMrgh;<fjYDjrg@e9)I7~Y{Lz{iKThKoJw1hFwRUTbL1`@YlQ@6@5%5>jE|qZ
zf8(*aMc=zGn-2FB8i2paGp}wmpD-jlsRbkwziE=veYH^4SyG`T6Tv?6^uNm-G%54!
zHD!GiRT04L?|H@2^!*kN|3OU?hYZU8%&0A6{4ZOXl{UlIle!;nLg^@PFnpvEr`ld^
z8I$~=<^V)caaV@F5m3t+KcnR3c(pSE0!6O2)Mql*frKN`I_%oU=k_vjhe04f<e^n+
zy$v25YXvoK^w}RGw(ayv%r|pYveQy!akb%bM+B&i>ysQ1-jsBGW4K~w^5@Dp<5kMY
z*LTEGn$#rv6U1!JnwGmk<-W18&?87m`VmQz3$8R=sxcOHaG@q~bd@&qUR9F}WBo7u
z9P$wWRWRtV1&=Z+xhzth=-@!=3>bveEWYxociH9gGuh3~3*LWSsY$%%Y7;c255P|r
z0AX+7LH)I`_p-!9V827s`%=Ox?{_8~>uU!Gz3}Acpvj#KTzlwd!mUh}lUt#)`fOo{
z;xQQmbIH?J>Laz2e-7s%a%kVftTi$QC}To=<z5MXP*Mt#nP-oY><MJJSaqxR(_e^-
zO9Fcl^K45-s1PW+H4c>DXLhiFzm9W3GCpY87ETK+iLG~z4A(sxC-g`kyW#k{)UEJK
zs75SFc3A_MOlcJ9)$fxcC1)qKhMdm3s3_qwa=A<&@95+~p0+D7k&_u+IwHNCC$019
ziX$$g8~rPvmd<0_E8I$BywBED(kw()Ft{%FeT2j{KAONo!qvWl<V@xUPI@t7!nJB=
zprH>R*7<IOCfxRI{b?Oha7Sk4kFK@L5ix07^X=<bV7Z@aaA)&7k`gWp>|R-28%ekR
zFzy<d#hx({Mdx8(R5oO{JD}YnyE!K8YP!QlBd}Kcwk(mQ_(Mf9(|wEIcyR$#<o_P$
zrNbi4OFcQX+Y`4=#+`SHR3u|VN6>D-*Dm#`aAI~54AahS#`rw=PrsP#pWKT`lssOq
z*RiY`b7^KWRq^JNL+tK!sYXqq{663BC(5QuGNeRa2X&VW^#5X=2X2n+koJOaztVoZ
zL39M)=B<-C@frF`#*ryfweGOf^s?<fR(cm28SuY+H;WpExaS-5#P1)77hZ3_*0tZn
zIV+?1|Fr;Ww=JShX@3z0uLWAh#s&v|p(<XQ0)_js<{2c3g{<kB=Ol^gLuwL?{+u32
z&^vu0IuR#d*)ZC>@jl|UM$Oyk;dU8j)7e7LZ2|}7@Ss?Y9|a+x%xkp%F>g)+LwEjV
zIdKR;<VT%801<e+(fAT^wR&Lh<1PL3=(k)n#kCzp=9J2NE{uXQ;fBiG(|t9Nn=?kN
zCy;QYRsNT^niO1j!9M>Fi%hW!c03aFRX%})yhZK9XBBM*dvXm=GJ`{9e+8osYvHIa
zSIXJ)Mt$xxyrR)AG#-LhR>rZ)=)c?HlcZKydCOz=K#ep6iYLQ<YbSFue@n2<6osgg
zGsL8q8&tZj;-uLe(VPd!_IovII1@$wWa?PL?8ywAJiiGwaJ}q$pP8vW!$Jzuy)6qO
z8<D|#FGAkDlk;$yt-I8}BY+|Nl6+SGwT3JE#LW0_rcXk9y;WNG(UY>=Dc-ZMs$WO3
ze9@Qeo6_#C`BF_1uE|D4a**(cJXHdO9*!wq926#NtXJxPv}`14W4d>ZU-z8N)BNQ@
zB{gpI{LM-&Vp8sXfxamts1vnD$Bd(3pOi=hHLzFZm&obLA>nTM8yi#Uh+_>4aR9u3
z`7qrS6#4fw+2XaSkjSlEU~}nZt(uP#6PnhCEkmRHOI=6U#Y7%T<!a|BUSLc4dAyNr
z8guVe+jTPOH&*)e2j&uQYLWE<z0D4Xf9MARgYR#81}Qn&dFi;WozF#N^2!Rh41q9M
zQEAzLC8?2<bJx?gwDNEj?wZfKK(t>GUy@E-3WGvI6@Np)N`4m)&;w~k-le}wQ*jqB
z7Z1!MUltEelU4ZW>DlDV?@unZ-OaNw+C_A5_FebQ5%1uIP0UO{hg)L6xPZx{!-e<X
za<zLt-yse`l9@o}>n3wiB11pm=V_qiJjDF;enAtd(ti~(Uz$qVnt$nWT2hspTs(-n
zDFm!>C6o9Ic}-3+EEyW~m$%K9@AW>WpHkCCzf0Dr$=U|o=*j>lscrFaO8H88VC=zd
ze{(yoGCAX>eg1|7XpAX~7W#u~iAkz1(!9$%(Wt1*z26&Lp-~25ks-?`Rm!V*>b%A@
zRP833)vHIqWsZ0g@f-KxN8RIVVf=KuZF~@oW{h5P9|y@0%UVkdn-J-&v|7Piq`QH%
zKc4#s<H*g86DcEzD(yd?ww_lW)A=-~-iwplI|5NkF}m=FCLQb}*$Tqnw;Yt8@qhhZ
z#6ua6cX)kg$@5z}D9c69O&0%*4-Wh;bH+hi8f?jf6V~EGaQi1x#u?h+fOhUU?ABf=
z7}Oh`8<+?abbut9HkUKvvM7)(NgNZEzGnU*l!gjkm&jDT?)%<mV=meI&fZyaHEijQ
zMMq)jF3$G@311plx4KLFMT5l-dxfX<6FTF>leB-)RyJ}UQ2I;oXcf5-^St`rH~4Ld
zi)MoQ>j;F(-Dc4@Cc~;4EhPsWK6WrZzQTXnxTRYaoXkOU9CWwINe-`o+hgi0G2ym7
z+P+bOGtvLkIHW*KC*u7nta=x#QW@|)9iFLz>mVaM;cvjXN!RMX>s_=e;b+}S&{~$F
zA~}6tKM*7cRrbhho$G&#uVh0u=xrG~4jryDsuhcK$PiH`*B`7N2VQ3!<+%Yd<DlW8
zoZb(jkapfC-9Ed#|DQvMFG6u^b_?5~B4W*$FeB|gkv>|sS}HLPm_GT143zn7uKDZ<
zf_tA}7BLhg`uE1H<JEpWm7d=RY~V9C^m)WX5$%jLJgbw=IzbW~{*0+xhp_kXnR6Ak
zQYD>Fh0Ak7f^h<8&D}nKP{JCzP+|#ue0!GsFkTd*WyO-AieiUMyjI1;)cmoN-9%G?
zW`>KD#2FK18r@GgLg=c@%ii}+mV?BIQZCU){u>nVh*9;EB)lRcHr^*sy+xJr(WZR1
zdVyd+c<Q@^eQO9ewl034veMX3eYE;vI|5&H+|rON_w@l!L+#A-Q-+4|yu<@`)4u(I
zz6Iw7BFCYBi?iAoa6hkgk5W{BHAL$XCCPlAK)?>kMQDX_Z?0qSsk`u;>LSVojzu${
z!<}`i{Rk1ycy=jc*#;G5ZglUN*}Qj7qY!TBd-b28y$Y#GCX_N#B^u<aU>5qwMq$3z
zdvZSeAe33gwq~Vdj}^6uy)U%?=om&h$x5Y(_C8%9|DsweeKl5No%qFbGE#HH#DQ=I
z4;JrC?o=*Jz>RXro|B$7HI5$~?Ik7D#_#Jlpr<vGu$6-*Fb_Xf1!8yxqcqTMwse?$
zO6YVpO_>2X+@^FSexA<dYSpcO4x5YOI^-_Q&0N3F1nn^O%wH=VipKSmh^gj<$Z+_p
zc_ftbej6RC;@^6aajXXST`h+f$~1C5wXvfMLW`VF_M*oJ{*ZnT+1I~*i9!5qVDH_4
z9JUPXao6Ivy)idl|C%DP<77P?#GA}gvz1K2^d3ZP=2w0QeC%5CiyGyZ3+&N(tEO_5
z-7ZmS{hQsH<wh>zhK9Ommslm!TCP7w(vCP>#*HZR#N^YXCYSy7KLJ9nm6Af|JmpgB
zMj6JaF@2G4dzNjp$xe>7b}y*Z(YHtmR}QmNgdbK)x)KEt)dnaswSRBlOI)qb$z)D6
znsEqv1&JN?*}rr9(N9Uu3i<^ARxcvdY9bEEF}WCk5jE+6fq+IG&kuK3@@8-Ci~Ks#
zVYXPgc#btgBZX_?b`g-t%N#czAfuFN6VIoyp;+0l47ggSVv7cy?jZK)>?EbcXPE{R
zDT(nK-47qnXN2<dV!yU^?mdF>5T!_K>l?*REBfHTLL%wuF`yu)*laZMpeJ(i%aIAa
zdHkEaFOleZ{*BAK2+WD-+{3ErxSN*YR$@GgxC}3CwJ(PH=<`xO?i;TTe0w-(uma?j
z5*82Vf5(jW7qiTZ-gwuwDDX-FaZka0(7!sDN0F}nV$topvFfD^4aw4^DW}iBbv>AG
zEM&#=mUC{hJL3NQ)-&6Qtew56zRs{^cgAxs$kqKm#2|=F#!~rI^v9!jdNMuzvigws
z$cPt9s&Zva;6LlS8TK(y&ByS&1!3Htfn<Cm**}k3?@<)GP`x0{mU=U`BRj$WbujKe
zw;4=q+SNxt9`~Ax%C`COK3p~&(-5fP@9l;aB)VDrNi!TaOfL{h1t-7-*RCQ)b8QcO
zTPS4kJGU9X!bOA4#Ah}z{adW{9&Eo3D(2M;o2*;5N2Q%{oX@RCH6vMzjV5b1up~Lu
zbkfKuvLub9Cy&;*B%plgxubOg)vNo9ga!}J#PNFiVgbb&s%M%czLa8)lo3-OGrS}X
z8MDgHh+TO<1t>6qer$79J!5aXTf5q1ReTD3_=%F&cczEGG|Nt5Qmh@KY(jVqLO)=q
zeI+!jUYA+^Y^AmLq3!DTk>1C^-FTJ$7Sj-*Asb|&6S>AP`edZ}W0!R0+wy(B$lyS;
zEZ6t)?Wlq^0aVKzf4Jvlq%0$baDw29mBWSKk9!_BRBizSIGX7N2aT#8@vH=>_I!F6
zBP{7FuNfvwgUNr2o59o8e9mP0gYatQtqK7ykg~S_%kN$aB@2>@<e#_c<fyd=^9ssd
zn-HZa<K&d7A2)wiJ&7%34nFpx>e*KLF`A7#%-Z2KJWQemC%#j4$#V>|VAxXaIsD)Y
zaRv3S(>F^BaSXWCF)R!q%ZWXWVrt1+Gh~%H4!PdpW;{o63FW%y52NKGw%DFDk_W)c
z)q(n)gvYn(XuA?X>jpulA@F+v?2e%g-#NpOPp2gj2QYm!m~7zPX^SE~tEbwBC$53_
z-?y~3Ks?1W9hehKs);+Z*rEDS{=xfCG&DlyAH5JeSRHqRu4gVcmYFl-Wl;O{s+u5Z
z86{jD%XY;d<d^?CPv!dl>tU$p`NM}$-EVNLT;a0LKQF<gUZ*H)*hYM?asMul36}Ug
zb<3$qbUY9)G3~^xJ=xD=Bc6H)0vY04?8`^ExJ=wvEt;N=ghf(U>Su4bqA%5GIBsj`
z)bE?DdMYpqVlr<F;eCkJ_3+Sz*^eJ%72cl=KSuBu;`5Qesw4f__zHhHEod1kM-c85
zzUcdiTV*-dqZYNOKJWQrpM4!#%ShY3SzHD6CQh_(8&vyN#Fj`dvrV57VGSA|`VMMt
z9}atgW1rE)SM|R8eHP(|H(a+bH8Z+JzGi6YIEQP}c&7E6N+%I?t8=}3K-5nATlRaj
zu)3-?yZ&GtHr7Qmctqg-T!5Hs#oyJt9j`fy$579M-@#<XS0>VnK^0W99bR*PMngC5
zL0Pn{w_yRjq;qHl!ll{K!nHSkUt4`xdxRZ#fKf=rxpn{x{?d1cptkATV!l}`jB(Fk
z36dl6y|JHQ;yJ2gZuvp6$y$T??V%`Lv7l@SXV2A&n!0kMNd@lmrKgF{t_M&dLRlkq
zr0VK{jH1&qmc)eDn0<3pz7X!B@K;S-8fkHdO~UaTBO!Rw9@#Qx{W_-{D21A<C<uMn
zbZ(3)o-^TaEdO&R!THU@K22)v1)r?-pj&e2Fn=~1W$xf!N`b^iqK{;Oc|r|Mq_HWl
zxiRl)W^w4A7(C*Tb@xa$Y5K(CFw$BSe-mfEx<(it<qzaH$NT7SR|;l>BWJ8+MDBI7
zG~1FLoly^yt-yxW@zyaxl2N%zqJ0)U7w<LjcRKXx)B&{C4)3+QH>S>Q%CB}7#qq~5
zp6%Qss4gDesRFrQsWj(G$v8Ta)CCfg7ZPTSHiciteCSXu$bV!(&EWj`W9k%lL1Ovi
zwBxNuyfT0Y)$#dPPzJnUlTB3m!=r0>@rG}I{pdT63w3<K$j{l4pI^~;O!_#dyx&KD
zL0S6vf}j!`_6d4^liQc6BT2A6kiqNQtS1Z<Gz|Nx!iq|eWuX(KfnFE7oC07jmHjne
z51l#<Qh_=(1@{7ZT^yHVAIyay_%n5z45vULaO0xKfW<1uqNjc^N+_N`n$bozQ8(3Q
zlMPm^z(NK^-r#_@*J3~isa1SBR(`p}c(wXtR@>FPY^QASiURP635ggpPRbYFB`=p?
z+zjpyG8&Gxhhegq0EeFWS^Vivan_O6BL@;H<!VV`%R&W~F{ssZ$M`{k@aoMcq*l?|
zl^zf5fg&?=IkJKZpCCXVOJcqs6y`2x{k?pHXzFDaH3<+(T|O24dXrI{f_M9n*~8OY
zB`Fw1m+J0)gUz2Z1cSwA)8I#MbCA?ZUjD<@4XyOeUi@lD_5U`PhE*1q;oIs9daeav
zZN@If6f5(Ldc7=?oxO#=69@-k^D<Syv~czQ><)u+wXd*crvghgvdALG)$%FwN72C>
z^8iU)bqZ*g+QKxjJw>7Zvf&k*30j>4Nk}C^&+BPwK4gUG!{^V3SGZWcQqEtitEQY#
z_zF`c+=)K`TF>4T(8(1^Pa<CQcy~~Vu%`EWHtn-{P#!&PVgI+!+Gu)tR_z;k)?A(y
z+-bFO>AHLVqP}O?Z*alG1?XS|xVLzCTU~acsFhQ4?^li{&m&)=9~AdkMX3`qZ_KKo
z?*!mkalbH&>NoLxQx1ZiD}f}0abKu6gE7_^{3Z?V@1@zo6|XNX?9>At?Sqp@dm^_2
zi#z&ly0&$VHIZ8xoZh3tCU_jCE|0}uEqfm=F1=`V{xt*DKH>t5=NNFf_{5#c)rGd=
z(IIzDEeyGT<?6I)&H{r<vTa(CO%@#{OONTsv69hj&27Lo8$x4daq}*d$3Sh}ZFUlP
z$~<g(NF6+d_ZiO*vm+uopWVcknySKON3h)z^MZPBUr^vTcz%FRBq<R9j`|>PHLgaz
zx<;u?kNTvMlTz0yxdoSI2$JpssGsN*I=_5z9-Vtgnk(BoD)(wb4q-={ao&8|aav#F
z1`OZb9b+-7SIj~;D6Vl|3;d9D!0g^FrzrXdm^BZl9|G^>(JU=p#yaSFh_}j1n3Jor
zq7?iwFG!Jdiz~CMCLkhrkKBM8Z2w!K3WpYY1}CNU@+ov#7ki9(-+d&Bi!8n~6|Gaa
z%Nvf-CP#=7^%ocpWI5*7ys%_s9A;w226w7}j-p|3g0P$VhU|+T#3-FJao4oDQqyxM
zMwTPE4#Z-YZx@)AfxypYOqn~O_DltEH_!PN8WX#Z?od{W*2f{<Mb!ufLebwiLMGD<
z`EGSEd8;J})Lu&i80FU6VtXB{Kz2*R|1&cRkRpryEO@;Kg0A_{1~p{$7_`vx$Ni29
z>~N;6sPpph2R5|TFw-dybY*t+gT<T*y&Y}rn|i`zeW9$Y;ccRvsI*%iyk>DGuBeJ!
z-}3n1Pv0neuJ@TfTCs^yg81Mw6c>71^@2IyQ3VWONxXj6`HCgh<Yqv@W0x7#ljh!|
zQW2*&Exu@eN*b>rORzoN#hVE)4rDbx`hIo-rehz}8<umdfL7-!ZA6lR$A;g>Ch%Tp
zDPju>BZ7BdRe^!Wqr?!v&RV3?^HP*w4IY-0nw>g<5ry04uLOiCmCu8Rc&j-NxZZ;T
z5I5fSa&O^GRM4V)sfxA?^FMu;)t1@H)6Ar7+EiK$OqQco-N0<h0D4vdpdubgMXg~}
zXRtSblJa0#bi`SH2?SpXjsNgo{tUOA`=fDW@eCmO=i<1FpG+w<sbO9Bp2ym@@9q?Q
z88c*=PzKK8ihY8#V32&~GStWAmE+&O&D{WUz&}3A#xk_bD}vaGjs%nFGzD5p`cE*m
z0*vTk`~q^7tXU6(5P`^8vf`<+uS<n_D9$hUe%85|{B<U>dCB$qEnL$>kIu{yCN5L&
z8QQKR*AkUTCW*eSi&v@e;kMP`{N-NN<Al7V<8ILbG2%0G!y4(;s_xScYPMKTH2n)P
z@dq$F)`*bpMPaNqC%NRhENxgZGB#J|87FlBJxfh``_Id@S7MJ5It7+H0f#Pqir4pk
z+R^*Bg9>*Ti2Pfh4OAY!q5?5RobF8SMF<m8>4mJ7vmRRhY59+Z4(x9SXOI)S0Wi=?
zkQkHKKj^wMDc#pJkjCPPSXgzRIfW2i^|JbFChxL2Ad6r@(TK_nhErZ1%)1Nf9o*Iq
zPg4#6?o1(mJT?F~Bq0?L0;x20f%Aw_OuqrnhbGiWUtOgQEi88eD695M=*QG0_3lyS
z&u2@bpj1X9?_aMMPzS!O-yd@^P3aP=<?_l`M&_?HUBCu}!MVj!uK!m8n*ZlO;<BvB
z*n1{n5{&tmCtF||@!@Fwv_HQT4YUKAo`|sAb}$YF)q^l<{KDfI{h(=9Y{*K81oyS}
z7hsNjhtW!JleUcceVUup-Ku@gd`s+#Ip1D8&HVWGEs_MzbGvXbeDczBNBLt&W|G(Z
zfN?_dvKb9l1shO|O>fIAj^&kRZqR^!z7t2;NWuogbZh`GEBN@0?p^46<*g8GxfsJ=
zJ`w1p9r>9BMacrcqV!+Y%+g~yfUtRpo%1SXfIAW_Z2Zjo#Q$YZ87V4pN;NjTcg<I^
z#D+EC<PL|=%@#I3TCGq@@ff;~a(u%7ZTn6M*v5*BnmVgrm-uH6a~9v+D-6D$!9sAG
zRNr)(I?EeEy9UTE_^q82d{qeZQN;{|tC`jl303!ZI_~h&AWd?+BW~(CeQ+PHiVRv)
zzu}Ad_gJOuvZNuU^2?R}8S<ed3-5bxLx+m&j^mfB>%o{TdVE9f2BnI)5zWf=Pqf#0
z-~O=!hrzY+fx{k$=JChlqv63T?P8ned43^r`l;$pFd0WtQ?{=u+Sj(jT7hL3aVVxd
z7epOXE<mM@#I?`hF0sCrW|+Sj0*;dCkV|WTvda|?tE+&Ovs<St2_J-#a<qQO)DTih
zzmV+&>7`qUl8|N4SrM!dcPYX|d^RUrHDH9qfFy8uCbJiyQf8v2G5%;xN~eUJNj!&Q
zmalAp&6L*WL740h2m>(ZyRoJ6w-S>bzpBgxpA~fuaEE%^)7WbtSx_yqU`vm;-GSGT
z>rFMujI(C(76cB?zRn9_1Ofm`r-Fcds~yZ$wByB%82*5eGPiorwbA742YuUkDzv2v
zcNW@6BnSy%WYIjq;A2SenbMP>R;8q-p%h7<k&1KRSSCl1N`mRSECm(=SW?*gYLEub
zY+`q42&hRsc<^PEuB)|FSAoSEiPy;PDG!2@u~O7c81$emCKT(dTqBe`fGnmgS5wfW
zu=>!hGH~BkVk+|5^0*``XnX*WgbV5a7p5w(Xd?fi=<7rww)Xp{?X__;q-=h8DMo=s
z=ihI{p;mrVm<}1lm>UOe0F`WFK+t=?ulrh<9mUE5{|1e1OKJoblofRfs08XwQ4zEx
zQaal*A?BJbXiTpb#6NYnvY<ud!}fmlnG&R8e&~}LUK$F|zr2vb$A!4!EX1d7=q`Z6
z_=QG{?j2ew2tj|LA0|I23-@d^kYK}N;ZN}KBUr>HKbruIm^%%ag-Mhm$R_!qg)N>d
zqzl24bI3ZgUu;5iBV<ZolyyXeVynubIqPOiTo*Vmh!0skctGo5t@`M8lw#O0$)H6j
z(=W;Uz<SDwdwDJlV%%Ni^}zlpOTr_>Wz>Ns4Tnm)iH=9SnusR#FCcz$Wp3tkQm!Kr
zF*8deOADOzUqo9Vx2y9&mfQT?Ma&rzN&woBk84)RnEyNgsOSU9wOC)F?Iy!RCI8^S
zC;4x0hbQqTns~f2i86Bfrc?9!84i65-f7ak^_2e|5vp+5qUoFmphmLzuggR`VHG;R
z$|0PN@5SqTfti+rBYDx;(qjo?H%+Ubp!KiaF>#2=LK(9HQt%q#ZSg+Xg`o~*xAi?o
zAO0?Hklk$QVYOe1f|WZNPx|ZtX-RV{3woG7@OUissYNLP3B}JiuiZz79=4nIOiCl=
zzwMCSht0(>_qxvRL#Z%_7(%J)+-J~J67@PAbQp_M8ikzLG(2GaFPJ8~No8*(g39E;
z0h|7{KoPAlSwmzgl4`JZx*hRA@_)zE1uN-gwKt}Pf1@K9encB7SDaFpguV~*SBJK+
z-zUGEP7@!%7g`(rb&&cOI@7`$l;2%I_$|+%Jw2yYFHcuZO#`HS_N_&pe&#|Ul+~8y
zGf2PJp}A?Xd4L_B2SL3der3>Q1(t<>pFUG^g`U)VfRoIE<-mIJ`DfD**km1jjukRN
z6LYETnWqen&c}WI-tBbo`bx8%%3dNbBUTj_!l73XBe@xNXnu+yRP3End&Vwpd|x=e
z$mM&#gWxaLc<1kWJ%t@FqETe00QDc54|p=OG;FcRUF9%%ggX!nm2txmv|KVuG$@iH
z4zb?DYw*Nx39sPK0&NJpRBaIJv=)v0eDwl6h@yNmQ8<!KDzNaw(!(OSp5-+Ix4Muk
z2Ru|&t9h5yo;LL_;I5rZWCawG5;@##6Y{)tf+k2W*j$*2_c>$dfRp4)3M}`LhkxCa
z+qVY=d%dkJ<ou6XvmE5oZ>S!_+ObcVXmkI-jrpy=johBBVaLjXLtBaci6By`)}zZv
zq)C#{%JuIwK=?o$;(qTKIC6AI7Gl?KXkU=cmGeHuRaN{#v#vD?mcO8}1yM@6bdt=`
z^0nXTQ2Ex4QUVj9u0$~S>=v?CrbW|F_rM)+si)>&fRnk<ZU53x4#z4r^k3Bnw@$HU
z$8Nad1^FMANhMnl_b-%TD-!qbbvVL?W+{CK$tMlwb_B+;qq$|j20-QZ^;kX?Vffpg
z%rOL&ic$n^Cf%r9y`oe$S_qA5wy($W{rj?>Y+K$D6TgEQk4$>yv8RET1mRxd+G%Nu
zeGpr^l?7l?&ZU?elNe!j5GU5HNlB9Yfb3%KtiIF#EJQJEoVon-XYs(^%_UycQkTje
zLNvaG<wk)Yap$MB2-`R06KRf=y))pOzA&6In@u!!4gdE_R*{!l`82TK2|SuzDonEX
z-2o_?s5w?$`yy;$LUYv!ClG#dQHpzGkBWFmtm}{fPL^NeAK0<Il*9+f3D{2Lj~BEz
zfQignShcBI=>lcD${RqOUO_Cr3z7qjT&KGI7^=e=(n;V&^MoW}R@ZN$Edb3g-o|ea
z!Mvb^@329O*5yOfdu|h=`|-h0Al5gy)%<5Q+}#P%cM4ozA#?ogWo_^>_b)sim${mv
ziYT(vkkdr}dn?4qThZ%Kmp;gP4Jw5@{khLCrTLZ`{xEv9^0{~TUKwu*vK{%0B)Z2C
z<J__O2_5i7J$-<-M=1g~Tfg@1D}RgvV)nRyUVSnMfqGE+{M(4-!2f$g$fLB=P`N$?
z)Z9c^-Dj&qRHqa3i_D%7?f5PWp~Efwx?-e=SnnS+|CY82Qv<<TffA06e6q0pJFXm9
zir!a-&OT1W<%DY)Opvg@YXh>mjSP|5>^shc$3bvixR7@f&ep0Qg%Gz=T$;`Y228hM
zgg)}0hfi_JCxwy02m`*S6wHN-hME7J-RS_L|9gdBZxYCmyJ7AnD2!ZOe@p}7wFI?Q
z&*!?YeC`+bO{6$4q>$n{=550rZa@_<345!-=&15&5%OqVjya^OGj|L~(>t}s&{&=&
z9J14ahn)O$>%j&{>(rudA~2mDoRhoqYbth}#33B_^FDozz96g`rG#*$T9H;~RG;<>
zcjSth99rA|bM>!~3+(ahbi}Re1Mwm}RK^7m&C>fE`vqw7)<o#C>t)Cz7udDl5o~Y|
z5R<X)RTI^j)33_L2HZft>Glx!6BEa8JG#xbq-Wx;%FOcCGQ+}-|GapqjZ|?DZ6D1f
z=xN6T*eN5d4kCt{hOd(jJb?4ydyWMUb^;qP%?{slAWqg32r_sEY8s&Er@5mKY0@t=
zs2P>Xm0B3GVa4G~aiQ0D&yPWtU?+J9WEmZkKW)d5I7K}EW>D+SwhlIsWSLBuFzcMJ
zQN7wk_@&f)V^knQ?|eKP<IdtAVpJ|`$#UR6f9*qoY`UpdHH0uOa2WG$77LkzDB<!j
z_^z)v5O&bGqzVNJv61D#7u5;sGkfwF-XvgY+t&r^`B*bzEoMG0{9Ah#TQ@M%0u*id
zFat*rK0kvJyE4>nMGi~Fq2sQ3BUz>=2#@Q1QkGpUTk82F4YRrD05Al=MGA+1H`IAC
z!W$F@!VgEGLB-+>#rMVBJOvmZwEPKK0-{yJMq3<4gkKS^XdL^7hE3x>`nL3ewIGb>
z2yCpgVWHdMUQoc}xTGAy5-<%MvCGB9H(5~@ECTj@ygvb12sFs(f+Sr%u&;?QL)8K0
zfLelKk0&R7onmtsh@<1c<A+!;#eBYmoJwmde6$a)<~>dbB6t^IHq)s#9TESBXZtBB
zy)K^))laVfBj||o>MM~4uWx`0_~y8Afs&g9ADv<ZgT%+~0#4z!0h#!WT77bh5+3QN
zLxS_9?DP>6FQXvX53d1miEz?~h6-!`Xt_iw!@4TX87)9wE0z4xH((k`ui|c9;Jzp?
zXAa(jHcaA$`d9Y_w*O)-zPU=gmW_vBp4TYKFw&1(Kds&WR8KCUeSef%U6K`=Sy_Q?
zl*hB@#VU=Q));<$>i=2d_3#?F7c8JxX&|rz{5`Hk7+)j6M9sl~k3OzL>r{Hnnrq+E
z7$xNyH~}>4$_&c9L%9EzN2bBi0E_wI&n}(Is|~Fow+;*0S$LY*(aIsyLxg^fw0b!d
zHebDz&6vaFBg_jb%xeQvbZSxLd^g<c;=eLrSSaj6;E9MRF7iUL@QSRm%ar2cS6S<`
zUm@fqL~YK-LkjdW@EWu1<w{S0E5huHzUh7@8MoTE4LY*q18pH)>pG~ZvwwPI^f;zD
ziPc>5e}TC_h65V_N;yMuMZZ%1X0?T*%bw}*69zy}k=S8<f}ZKZ55Oy<we}zeFm8T$
z%7V&fSqFD4e)y)p{5tdi-g!3hkyu{#>$g(qr?%Q7U8o$3b9}z6D+z<J7RMmSxd-zk
zx~n^>*|2mdSNyKkC#F_$pC-uixM$;8&>VyJ_ek%z+*kSXICmGsV7?TAg6efSK1-dc
zXnziomFgK`Iu+8+a?yaDD+DO;!o?!P4%aH3l<Ru=XAnkO(appMyAM+vC?G5Rp$UiL
z-($7Nn=cQPOv3Er4ug%#)vpn?XWZV#k1-&<!b41vcrRk%W#3xym3wlq_T;a<=rK@O
z=t3D?!w`R&PJ;%df&<~XcJV^HHP?hyTAUOb+lz#38fTRx&o0-=GoDS_=t`3@Gg$+D
z2KsBZw{~kRBHEtedAwaKZQ~bfODDX0``(==1cJ2Y1?dDW>~sknVvW#fYW;<&zxZPc
z4qYdk4iF1!%kgRk;rnwugXK@@!;0s9LFr2;NKiD8fumfcue60LnY(QhQb(NGq~L$Z
zNqjD(Py4@<h<REASXX|am$ww*o(QJrR?9_{>))rZ(~&}N?#8-HO#0|M2Oy760@Xs`
z>P8BNCJN8@PIB$5j!5SdSmd><8<O%E7H3iEB*YgReuHuv@jj)<3^cz`W3rH2&xVJS
zt1K7XQtU=-;aF9}RwOGTf3C<gFS}{l5t_CIesz3_u81-~7E{BypmOQW^g-mO2^xS3
z-p@&ywx2=uyfuc-0e&%P6=;;Fkb1EsQltdQPY9;=?oY(v0m^;>rJohR8E9l)A)6NA
zs9m~;s2S>zdV}ijx`U+Wgm+zCgdz)`E6GcYDXJ|5=H_^fPJWJL!LvtK6-^|M+?4gP
z3@CywJJT=TQ5c#K|K0F4za+X8M}^WOhUqx>;W^?OAl!4?cBQU($D9k7#iFrG`Ow}v
z2^PX#@;}nsM2xRaSxs0jcM(9tUCbqN3hDjydEhU?BSa$J`=>=$-2WovbOrP}WpE7Z
z7xO!8Cs)5--SRv`d1E%o3VkTg?+r})Mtma1Sa?Qi{Bg`O&=OD*E4QBeZ8t)MYHm8|
z{U4<lI4=c2@Z8F(L6ZZ8{{|8UUNrW_`Px^bIMUmqY=g%pKltc05Lq-PN#SJflHV4r
zFiOR9qlSRuMrkJDdxGd&e{aB4B0}XLW40+i?l#x+N1S?8rZIT1QcC|$w*QOeCDDjN
z^aQE?O{5VTs(IV$7q3O)@zUIeVarvR<>GpBOVH%??p^1iTo0;&gr94Ibbw~RJ+#P9
zwTyBf5;X0RV4P!L@qjCE;;k8Y%cQl@K*O6Wj?5suo3qX({t-;G3CpTB>vR0%MmRP`
z+~?P*1FA4J>e7?1U%}&0M=hsPFo@hrff@xNKHg<v#LX-urMtpe&SC5WkQ)wwEV|WS
z7UWbKLA7fo1*ji<#l=c3A}9brQtu6xX8*7ew|^T{^8v{Kyu;@dSOickLWpN*b^~27
zE!)%Rh~wvC=-Xm5G$8dCf|gi^)U@G72qriHkIt-ppApOr!SCt0fJO=4$pgyvY-B=^
zjLNI0m}y0GXq~3RG?2mrndS(&Z2=-c1#Jw;YrE1AxlV%V+j^5q+!g^Rc5||A<o^yq
zJEjVNUsPrL=b8evag0W36rM-#x8u#WYB~R-e30zu^7P^201Tw&_Yjh@7l5Qg1Wa)9
z;+*<S#)|i32Q#$N?@Dg_7h?|PH4Bz?2tFbZM}G|W=~>R^FhxCgvUkI|0BCl82DpQv
zLD7E6opK<8FeQ6V4h!}1c4CaZ{)9}vOLn}YlSOzpMOdfeD`;8|T#UfpU4*;ZX|(^+
z$nk?QGb<Mnrw@e73Pl8c|E`-XT2%qb=x7i|!GPb<%5RR$hUI-PRqQ?haVsi3(kXvL
z#S>w;3a%zi03!B4yuexzP*t=M^gH%)+5V}N7{`>RMu}pn+$f1GL2&Yp;Zk6m4xey4
z;l?;n(pZ0n0_e0;?hfoF(m#Kz6m%LMIn>b;QnlVJw`eA%H6;zi`*EdwD6l*58pd@{
zC1SvXK6HHzwBWWKZsbb?K=lW%=@n$pTPHhu{^zLD$uJ{6O9hiq{ig;c&Fmp!!>4RX
zHY8XtU>3uwN1m03NUV>9t$RX~Q`;T>Xs9YYz{f@4K-Dfu)G0M+*}c*>53oA6X3;S(
ztD<Hw6=<9}XiQB)Dt!(a=s5sR6D8HwFo-h;f*!f+ADBb;1-}L-z{|jmc!lBsgc9;;
zf|sx%Qu64h67!%NC-&?+$=v~~w?NgI<xExbM=YD{-RJ+aY*>EO_~X4dHK=x|vGIaa
zp>dpT=S#q(7tJ#XAYFLFKbX8kXe6Ojcu~qH3`ny#$(W_9elYIqzr@Pc*sl1Xt&oA+
z*{{2pynb$@CS>k*GUAJpIa5q?J$m~=X8}3ME0g&jJ9(rs>8JfSXgB^th@iB~RRHx1
z=IH$9X@}`z2+a%S_6wMJn*PqWUr($}07ZnFg>JShttjx?`xdEb*x2`nl!u4_S_5#&
znXk|ya$hJqj_!ImB^UC((i)w|CMP?ThTj9RqY{ILMKSE(u(Z!BWy87BG<mHjPizEE
zS;$Ey_0q4NKtsJtzU`QJMkjsf_IKevefe*_#Q~SjmL4wVUHKC1RRnXFHLio3r|e+M
zh{Xt(#Qh6=dno;hx2|<bvLjjg2;T(3U6|99eYc&l6@)9PZt-|PH?zxtMQFG@xfq8C
zv$)LhdJr-I&I>x(el?IkChq6nP%sA+k8)qXsZ)D98^UWPQ%(Ia^L}0r#y?i)A9M3D
zw>=MHa3vIhx{NR#YtkejO!<czDRiiJ>S_F`h%Oh@)4~z)UOt}?GW?IE!~xKgqrJnq
zeEUIv;Tzd@O5+Ga$mGwtKtdP+A@|P*mcLrL-y#JM1HuKE`=~d)l?A8}e5Cz3ebHNt
z&40%~fZ@)8ZJq@clbC$2uzGiB^3FTZ<lobJt`ki-r-<iw0%(u23p9g0d*d;5*=b01
zgi+i*rxaa#92UomMqp?l8gW3EM<yn(ye~BvXDnRr^A8}w;qWS%p@W~!1(Lqm9aiQ$
zF75AbVH}EU&%AXSubvDf<;N}+Ryw{?ZAs(v_>2IrNZHU5<Y^A5w;UZPa{#X>2c#4o
zcm^TZ(-zFZbd3b&HE3$p{$xx?$B)AJNQ11!PXJ7vukF5K@Hk{MZRAWewp^RvJK&CQ
z!~_WU8*3qDfyvyw!aEXMZ*wjfbJdx!9eXFE*gSw6M3rN8!5Ug~QI#dVEEs{aY#09C
zs^uc98b<PtEmy_PpHBcqy0lt-<f!Cb!+3&un74h@r%8Fbu7F3n>nu0tp&8a_UNyzD
zz_tvbjK&sw?DRWG`{Z|6zt&vS4DS*<ByVEddq>}15=wTS4XaSzgSta9j)-_?XWnzr
zt*?9l3=bFMxfqz6SSjZ4%w=g==I=oa8?Au)vrLGoGIjMYAu*M#GKOWH-9wcZCXdfx
zw8oJ78%vlV7tMeRN$<vWjA?_wxm!Usji~lJ8KTQPwK7tgjn>#&(~M@-R?z8bMEWuz
z%%RZXZGTkK`wjZ%7UhYkZT)!l?y#S>23Akh5iqw4ym>MeCAv(skr7#qHqpgRI8H%q
zQXGK@xZE2qD-c>~)DMoaRXxV)e|7(G2uIndfwfkX)Utmfs3I=V<hxf9GSkJQ#91d`
zBL^s+tt)uaHQXCGJPvF=+lFJ%QV61NFjgC-*bhm*7K@j2_B7x$T3I|JYI4OB5vOFH
z{NnfSWiQsbK2yS5)iU+^L-^U{zjz#s5~qdS#(Cq_8Q)D%``7F<awbOCT3*lR6yU0T
zNXU7LF^`TCqvCby@Fo$lw)o;*VFR-&C!x={Bw_)gC7-U(_j{kZu`?uirA?eX73)b7
zw0iNI!;ZAyp*S6B<l)ivc93QO5ndjO@e}$8bMGKAnYsUHwd7R@Ew*T9m5T)eh9xnx
z73)HjM0vNBrlzN(|1Y4wtRQ>aocG{4d1%4Qk>8dk!0~%IlJT<c<-6}HJx*DiGIse8
zsq;Kmee%2y8e{G}e|qz6Q(U~34*y}CF}f_vDD2sb4qTm*>}pmiG7>U_LN2X`HjeWo
zB-AYS`4q%~4lPV89?Wr$iM$omUCOn+9IWdQg&J&5{px$~9%S9pnDp%WAMnm!IJ`f!
zzLZ$zt?0JOP}hnJ#T(-T<Nw)uguU{riO)hd?R`vB7GR~rGp%o)&|Xdq0S-c>oU2k{
zfmVgfJ2tm5h+KN(=(2K+7giN^7B)Y}iRq#6RmjA~T;@{TZW}~=1FO31R|&YNi=Vdc
zrz`Ol9CW{qFKjs+*Nb{{Dma!EAKd}L3BC%}EUL!RNFg?ssggnQgybUL`?VTPJ%M+l
zCS+;;mm@$eTSzyM({m~BTsOJIvboCN>C5&OBFRDF86z{6>bzNPF{K0+am39`o++Fr
z_Y%I{qSNq0BihKx=|lH2qj)O_-tmU0k`h;Twc^?JK{>JY4*9hLNtDo!ypz;gHsy-u
zGxu$*TD-{Zj^lNOZ7$XE#M~3Psqp>zY3s_~5KyeNby>0q)76|?M_<1j+0g6TO!Bs&
z^g@`bRrbYUp^d^=y&0;7*@n1EMID2l1oOeM%$Z!7t&S+Xrf{v>VvQFQi|5VAYxmg;
z9_fe;IIx-sBxKUhp2tTa)C10fgcpw4d4{A6Y^|3E%mZ8~PE@}7UAe2-URj4xRwsP<
zX;Swvq42*eW#P^0*HpOo<-+g(izbM1i1O?wKI+}EM@~y1`ezns*Og0$!((O`pv?FD
zhENPcE?z#AmTrG2)<dfReaW?6Y%C_M214_RJ%S#@e*po>(A$Ot^Yc+RfDrOsY3Kio
z@ZavWU)lp<0v;oq;!NW+n>scbU8-NiY_3F{R|>)#6Fhv(KKlDb0aefUY968p{{PqB
zTSisYwc)~opc_!w(h>p^ZjcTssf{!!q97nG4I+|~(jn4a($X!GQi3#6iYN#Y0)n&x
zQs2FN-tRkSobf*YzH!DlW1Q!Q;}P62*IaAOdC%*<f-biAjAQP_oRg(yrwOyf_&n~4
zz4*3eP0@-=@!TAJFxBCdILneM%hW6%ka!qtvyC@Ff#y4!%b&Y(LuHhxaFgyms-1FC
z?)s$9t$!^c&zJvoI>%|RWoVjkt6c0C)WzF)L(-?WR0r?28Ec>atGECx`c=|DorY6*
ze<>%kTYxgLWxgvhQO7g-OfoK;bXW1D$!s6hmV57(9wHz3q^jp<(zyd7g9DnMG^LO(
zvrl%miKtd@DQC|WDoH%gl%7~WpXZQaxDTK|k4lZ%jDhAEO2Z}YVotQe3wD<n2KS{b
z<@Y1&)iqBxXNOi;ymG&I#fyu`1`BIld;xvQ*JYLVw6FCLko=fGLiW>yKnpb!<AXqU
z{kKyFN!eTxGBMj8T&kvX@rlpH&Az1v)$^i$R^Zz)7(Wa?G^2~CsJ8It!_L5d{%Tr$
zVe-j^+#cYiXLi2&TUsPB^SbX?9>|?eWQ*Imyn$414b8AEVjnF5C$wlQ(U*hkViW()
zVY0C&n);e;(o`ZMZ6D%zjTAVZK<y>heF4U<D5F|(Nps_6($_xH(qH$koZbyem)H)2
zQn=5#BvW8egn1_g(K-|{v`L(IJsnK^sD!_x$qeb{{YhwRmMx_%Aw%=vJRqH%RUZj&
zMVOdQ=e;7S`7X!3Ywv3IE@w(O$2x^VcIjmgfQ?=?16rs~>j8jHLDL1=^L7cCW%*Ow
z@_a6>zix}_|Jj#|MmWAn|A69fKc}4U{fhCO)>i&=0Xe>oxPA(If{2iR`q$}sKNu}f
zpMQmxX)%5lPGAkeo7h4T$*5=sllr);lCl^IGqx;7UWjYTd$i;UWpUPgp+H+Z|JK6g
z3VD{PE@=GeEYpTD+dESv7-iufp-wJ6nenZtGLz(!pMhgYmGh;SkK9M|NcHJE>rMw~
z*8s1vxcSw4$%BBHtBTyu<w6`4l%#O?%0~Dy+h0fcFP!^BYJ!0dLo0GLZW*7gaB~up
z<`!rC%e<4uBaQGmEVzIeHCYFq`^pS8c4R<p$OoQ)*2#KDIZ$zH@}~h-^lFH?c`cGo
zR70^^kIDZR;quAoxPWS$Egpg(GkGNuU0l`bW?W+xmOryW32@Z~z+hfcOL=?t?DP5W
zF*CY84TIhy!9^9B$)_hrS(;A(X(b!UHB?lgVIn9W+A@>hl#}LeLRpnE=DM{+b+}<D
z<TBzKdjeTF#yr#--V?GKnv)vhd4mJ3@8;<~`Vsons5M&ILe4+AEEG4synYxsX?02Y
zML)||)b&40IoY5V!oD-OfSg;m=S*y#ABT8{9=p9gFB~H2^@lu_B0~j@n?wu#Wy;-q
zL9>9r5#)UbZP^9>jp|;NKZtAcD-`l8AK`&93m3>eSjrlHa4?k`W|wlJ@DWNJJn<|H
zIB&>`LDgQ#>#HJ}-DBzNa@7$q#sDqjH)KR@OPC31>6@xQ>3Ozf^K<3j&dQvnnZG#`
zlc_rP)?R_7#d?gpsbaFH2`GOqExGJZvm0cU;(r3pH6lK{8^8*7ISIYhvcbg0W<8#y
zKCOQ>F2sq<#sno;zK>waCRoCme5?P0w7ou_dC=EQ0}eUZ4)eEU3`FuxPx}J7nB&dc
zpSQIg5Q4*Xh-9JAO6b3WgW6e}y1y*ZFRD>F@Ukz*Bzn&ApO=@3(RHvOu@87um#R}L
z#TIUy3OnAz$nf@6+*nJ~aQh09;D1Kq^XjI$dvIU0hAE)491J^sybt)}G_FYA_r_Cw
z!~9N#n*Yg$(TBu&yAs~22bTzBW&l6C>rUbrJr7XG9k<I#+^pg#L@B7e?%--~8U8Uq
z)X(!ymA^D7s5K2aoO1$*i6gyl^bq5+MF&Xt8i&ANcWL1>(Cd(}=KKumQRYX21cBX}
zt%QGJjdmGu0wY%ENd!CKpjakHB|O}bySmGW7d%N`GirlHtwHkz5CXI@Zv3&PjErh|
z@n0{@l#)l=J-RE&NPY}4RPiws8ER-;0B~RbGAN1<vvYxH2F({JtO5)JX%df!f0Z*1
zbs{O)!qbs~uK^V>dgK63@(jv3iJUswTW=2#CH{HVTjnw6@LVR$sPYg|Tl`&PH0hGm
zrw-&Z@KDxt5!<$+WE))9%eHdm+^8+tu8=HiXf1m|u^Q0?+K<ckaIQ-K<<6b;g}!=G
zVxJGr>GqzedKO$9`qnCN$j%z0GN0NTYHNY|Q#9^+vJyYqC!T00g0U_yWJjoEO9zTJ
zm7bvYY-k(_7u6I&_PEdBZoOQ@GrYx3E<zUD1Ac(<Uxzc${ru;K*Ko|5lK#0(r`8yU
zBVnsrRJT5ae)wmvJMYQ}|G6A=)J3ml$Q9!(YzH>hy?tBAfo5HJ8yp*W>e{Cz(U|9N
zNR=1N()i=Agy1W?pq~K8X0@5zxmXEvqZB9M*5At^!13fX&L(}ya}-td&bBw?6s1Du
zE>IkUG<u=mZ+T0j{j(XJa%Ym##04Lon>%^Xe67i?f*wNYRv}=HO8Xn%=9w5zf905p
zq!s3l>&@ZGzBRJ$g|TO2BWv==bUlp4QI{<gCJ0nFQq^N)At%kR`lOW<fVI_(4S5DW
zZ2>8yx0Rqls7?mFIH*n(5k5dnUU`MJ3YG~Z@FYMK@zp>mpB#RkmjE|2l0qSTQe&nb
zPen`x3E(pXff_?|)ok!NRlz4W|AD}>5Y7xaHCZA7L10HA=W7bKEcE>kEH6!91UW_8
z_n;Ce`4C&s3nPeYFwxf`C9KrCwR%+n%k-N=SruOi!y>O)f<e|3Mp5{siV<b)CF}%&
zyu<x22EbP+J>k{8g)noI&m!Zifc7GqGNwN`0QW$e9sWHAUqaFb*g<VK{1=he80Rt?
zp+<qD!sBH4X=%MC_l@CKYO0xV$YYuKik>;kDPcNvB|?kn2m)^uUi}!)nuWIc)zR$0
zLT*x?-ElW60Bdr$^VwgbVvIjr^86Bj8!_rAvH{ygIV{tcKO{N7SjgL@qupSN82*o$
zBJ>rku@H2O{z17IH&F=ih7kX;-q%Bc+QQN-Ve2D>7eq|Yf$%_X*V^fC!dvji19Phg
zPMD#9Dix4B+*UxqW;cy(trRpE5BW#M-hB+X$TP&zVCkg<K$+QqHfMv=`Yce>xWpJF
zldj_d^NoHJ{u+w(4j)8_zMMaUoa0Tv$sE_q5r7`n#jbNPzOB$!<d~mLFXH^F1ONw5
z{p=G3#L*BNvoV|IILI#AB4Soy+Cz%yWqv&ZRvKaX!`Bn?wg97M!%u!(WZk*q0H}A7
zTjit^GgxM8I_$UB1KEiqquz1x85npcq*<i#YXgfWMI}2OmO4tXqSiQ4+|3vHP&49e
zHPukl+O!9+IXN(}xf}Knj?@m=QX+3V?vs2qsMQ__QGQEBKnCnCJsljdwqFU2yL$L^
z0+>}k0{P9`+0gfG&KQVCZ<jzYLI{$f70s;hT{)q9WzQQnI-b={MLX@v0}XHj>I66}
zvD+o^_A(@25!Dl@no;aKH1|0DzjUdXFlk*bas&5e)?x@L&;mc9QpmN}KG}c&v}EAg
zm;TSr<NBo#nWuv=Flr##YM!I4BV`oZCgtN`JQ5SOpase<I6wNGr_f3lbLKoNce&%#
zDd8ri8!~tIqb<|z+X)g5rFSxP2=9zwnOZcS0^no=X*^ocrYV6XM`!D;cDMr62vx+A
zdqxP~`XhAkQlw(zrt<>*r0}1DB3mm%(yJsVLaZ0rl}gVGPY%U|egB~sb0tA<<29_M
z^iPxXcqzEZ580i;h+7Nlkq?dM)&<I++LYD5bcRO8eb^L!C0g}r3}f3eu+VrnE(T2T
zg_q)PvD&qXjs~cVOIl8jzZkw`SCJzMoFwdA^YD!9QNwpTh+>&3S$yHa?JCdSEK7v{
zv{%2*KI=o}gRZ6{)Ps>|g-cdS?QO{CD6SCUNAufG(EUYU%z??4bt+~CDm^ZdtkztF
zU|BIA!C(VmZ1SiS0TBH&L>*u17K}1<?ngK*X8i)rE!Ci4AUl`_UZt4pg>CNPhZ3F9
z@h3paKdZCH*qaTkfbw5(R2+zDyk83VYO#@_?t^fl5{RDF1rme8vFe>Ci2+#eJip27
zAW|g!&9tq5w*3dtRR%L26RyX=$M4psP68_U2KQGUC}4CQf}M|_BOmgs)c{0w)6X<c
zl=2&0YDaEol4}tA8)a-(g-M>APG%*_iy)x>)iHPvJkx+BFPeYi@2Ol`53NX+<%2&3
zPl@nGF1BH@aw9996*vHfUl79hjCbypf_=xE)B50BAvOh7>FHgjs5B@Oke}bIjAg2I
zkl|O_W%4~BRlLdh#|-4Z^W)bz?@tmr?VayaTgDy!0kv9H^R_bh(N-KL=dW@T!2OBm
zmb0}{t1h28az=c#5Hdnl^A`|FN*ts*Ri}t=lYa%>sb(S47O<H1sUa%qMjGg5!&bj}
zytt<-b+k?2KSSno8OjH@-+74aMGV-UB>)xaxN!^}bzOhq(96CraBBia&VC1zDvRty
zA*XSzn8=a(*aj$UCH#d;Ko<zq=jHu!0_5uwaLAOdFXOvHF47h3k`MsxriX9!6B?g(
z@1Z|x-qSaOK$)p_yKlgOR!QDanJ&{DY5&2h0z%!Q*F4R8vm8gbYzN?T87u_IxSSDm
zxT`<rB^ne>GSnY@0eZN$&?vbfOzr)8``Cpw2Hq9K1?+Pn`%(OTFlV^8Ha@w$A#()X
zm&L*BX09-iS{S{-q@&Z^;fOLs<=yRqE%ZCKT~ETNIXb#1wk-9$`=6+Y0VGo}Y(GS4
zaq<&Kq@TG0jY@THrf&{os~-0B$$9v&vqjh$_v~HM<Rk-F%3J~n6N3R;RLxTnQpZme
zPGk&Ynoo*z)mHFH3G0Op;OWvqm?Ak(XHw^(=TN>C^<00>%9(qvR#PeUBM~s4igaFw
z{oO>FklCE!?l?5E`r1^#7=V=xmopTQ7=*CAvPb#HirBXMo!WX6CShE3UZ)uZ>N&NI
zxQQ6{)|%t;0;xy|2b%*rMO>eD3%~AWO!&CgxW4w}3{jg7e<#RnS7rZ<17b73L}f3<
ze41qCi)IA$DDG7H^&cnZ(LVvF8Ycp0oX0}_lD^wm%CoSlR^yY7c@p2y(h7jL;pMN%
z;Z-W6XXiS5((>%U+&#_0Y7U<O-(uGiu=5-#LEtbmZia96P6hM2_WA)m_#^){(uTQO
z#;^L&KrE#9BEYkNABEKt9B}!&&vS%G)1U%@Lp01M+BzsMCGI&T{u?dAeKlK(5L&3T
z%CX2heE+QWm{O4*l(sJ78=F<o#ilqMlDSVJv7-)_0&~$6U@0)R1HNjrOGMt1_8Yr%
zY*j{T@$hAJ%~5ED#?}DUL-Y@62`M1~XUU}aZ{*aCjm(>s1nR0#!<=&4?i&VQ&HVaC
zx&SRLlbg}%8*5A`yhq%t?GB@n&#C#^Hzxs7__<hlH<u}^LOC2LrLS`sX7qo-GE$}-
zwb=g#{hV4;2MzDDZZlxFaG_exjO|1O*Fqk`78YSqO`4k=fX({acJQB4iP~2XO}M6?
z2Ak1#xW9P8<XHyKnS%+ID=b+vr4oBF*Q63MJk~_l1ImiE(PdhtDMy^Ro91AOQ8FUv
zqMCekRx<b7<-SNT_ng?|JZwh3bN9mzz_D~kIL$prgon3Mk03shVduaydlarmi{Tn^
z($O~nus3fmJ+6VJKf>aO``FDizCZ=;d(jHWjh%MzpML?U#^OVOXqj!p^2^_dS-Q7*
zH#;~;i3NNSJA?+co^y5U1hfiPkNr2#RZ><lvXD2`tg<BmMO|z?;L<%Hu&ger04ptD
zp=d`R+CP%%RdRoidEFNjPiMh7Ok9NR4Db5x)p0$?@VN=B-KoRxw7X6)2<s(yO<i{a
zp-qYzI$JJ|T1R}lYof>vkV!Apt`nkK10=mpQ<x~Ntuwm5`nrnwC-|I8MC?tmp5a7j
zue>M<b<j%|b1s^jD5;YG50)C)x@nsV5!7Wk%{uSo(c0B9b<c&Wslf8`1EkI?OGGg7
z_8)Gzl{qa9wQXK^DYlS7CYk@M+;=)F@K`Ih`y(R2^|H!D^Cq^f@c|%#UBiil^#%ft
zzAK8=3}=#yQ}<bZf~<Q)@ZF!k&orrz^aw#9Fh)OEkK~3vOdzRck}(CiB|@na21q-<
z+3}JU9!zIc-E%oTiJlv)0gSU>DV`h6AkR<ntLvaCwSneS?ScAG`Zwx6r<1pQSCQrL
z<v00<$cA|!i>{SJz|kYRKhcI%!kRYGC0CW$$lZUhTKxoK{qL5{<F-m(3(0aSn{Qun
z%Bpy;LDR{Kl2gpT8xE$6OK`*eGHW?X>l+!`WcpZ#cA>>+u^R}r1c&`?$ZDz15O$5q
zIln}5bg+BR*8wVnZ_;j!{wrrD4#^5KlUQ%kWStVO`mRlCx+t7!2)x_5eMCg`5#_gJ
zGWQXmO3$e6C&gqD{)H%%dqf<C$_xt`q41PbYz`0O;2pH@LfHh>z^PtXoonryHs!&M
z-areOr2eKhOoQob3L;SP;~8Q?tG5Hm2=)2{{w|7!cpP#Vqgl)5rb>VQ5QJ+Gv4|Wk
zIU*mB(mLI%`%-Q*6zUkS%rcLS0VAI1VK0Klcn5sd!8}5|CZUY8><g5hB0NA-@)8Aa
zC7Te~ZLU80^J-F+1_Z9UrBCVn>tcKdK?`=ZYa8mw(rjgITBBi%<+R|zwMki1xfo^4
zIXaP{VX6vC+8b*vC*ED#6-kbLkosE+HsFmsi$_0?wTb^!rVDRVPpk5SyR*Ba9^vQ2
z{+T#xh4vT#4&UD9S=D&&$1;Kamg!IIu(S$_z>QM=4hDe(<D^PrAepUq(>}OQ$zm0N
zJ1GcnQ^V^rzlbZ^H?AG1YgZD(z9*p2Y=1iiUx`0!1EMp;oIXOmCCy<22~BhR6(;np
zozW8t{&mX4V?If&;Gfw~-u~k+Mls?eod>>2PwiKI2rqxfelbsdNI5^;WCcv%M_sv>
zLmqu=y4ZDS9zzfanE3lFfz_n#t9A?}04V=Du>9(@MoqX!{Z>Kx@5r1+DvV_n7zlxO
zL*(^6SW&wzcIp8OWnk51C0252u@tW?I1l*VJ;UGYDTxV9F6P~(4xI_qiGn8p>67R1
zwCeVhUx#Wv!s5N?B3(=5cQu4X{^esvL&hHh_hjMGfJvCXQ(@$#Jaqm$!74m&#x^-A
zGuzR--|4k)!;O%~Nb`UPNp=nc-UQyqY&oK?YUA*W6|eaYoVBj`uqLZZ8#<ho{{4jk
zLjPumgqz3TqHTBhN{5H@t4L`>0<hE)A#Q)CCB)~nukr;#*x4(LUKCyN|D*$uN{jf9
zn3dpt+>UJ-wcm~l;t&eZDA`SQObtBA<g0E)Wml5bTQ3L0Q~KI!^j)pp%t){2HBQ`~
zpR^(>IL@((m>Joz)w42_PsWPxz4xZ{Wj%^`urJ2$Cz>k${B~{0D&84xm?(AET|1)|
zyX&x3*w}!7M)g6=vM$~}<<*Vzw(n-OL6O3>Q_iUfPx4Ye+y<AYt<*E){GC4&Cm%8N
zk6!_B#$4#(=ds%v;P|!Z!J@evql%eHfAuYh_HzT#EX_N;L!vD`$%VJNqm!Ev%@U7i
zJ3J$Ee;AMw;0r4)yOL3tbPUu}aJs%l*M4{lCm{>tHc_G&Cv2OVMmzs#B;x5D(M-+~
zaku&KmvGoxJ_zu76R&IT_Wz12pp{QlxNYOJK!%Wdu-HtE0NkQ4`L`Il=3C33Zo-jB
z^u=30heF)xFm20WGD5nypF=gRr#Ln};bLYUtogKO(@`!G_CRSd$5``v(xESg0Ajj<
z0Mn4eU>xn%=7%3x6q|D3?%)lF+k`Q;H^o(Oq-9;0TQv3zNeL@Mt*$9lg!Rw~w4+?Y
zIt?U<SDJ=fWZKQ;U<z9E%RkaagyhXCl)d?_+vO;86zvg@LsatPL$UbQ`7obd4j#Ml
zn41^`rX`*-9=xkq@#Hz*o!z!fEq;Ujw_Yq;!)~)7f#!ACo@Xq{>OK*Z+oV$B{YX@F
z@Zj4J_A`EDj+d)>=wUt7S(YzKS7IUOt?i`KSs7Sot5D&t@9;kJ-n~Bme9<97(~Z8e
zb>1YI?p0G=-Yu~#qj!<MYln6(KEVq7@J-H1{GVgrs~Wp!(DSqjw0U*EXv_cn&uXen
z7Q7uSrR0lVuC?^5KwDI7y9{T(D;`+i(C$kftG73ju>_L|1l{B7YpGbbD+}Hu1o*py
z6fjyOdkjj~vSf_~IA%G|hc?f<?y41<buH|(kP@~M%RI{BIa-G<I|jwBr?9jmVuDjm
z4yK%M2OHrq&=hA&wrdOb%I6{XEHkE-fse{o82W@UT>2F`<X&B?8L<E6WEADHslji=
zw6Ch%e^{d_Gu0Z?GbZY?m2epr<-$ORf$Nowhj21ajCnZwLQO0S5zYn^H@dDHsGnVX
zaxtV+<5??V+p2;{SKV2vXq^}s*$|1}qtrjAzv(C%Eth5><t-sA&y(q&%_MGb>F*@4
zEQ8-ZxXO7<9N~)TH9dK3Kw%PXxXVm;VdxFHZz{7ZebgguZWWcn`>YwTyDGiXq5O+%
zF{AFrsGrLH9^nr(m7JMeT(*esxwyV@%F%$lh-}Gz-B@^*PNWk9b^-QX6(4nNCK`6;
z9({hZCk4?l*_vxLqxk>ek7Dn0C6n%Azac&h2P978wU4HoID7)b>OTR)BoBpqE@h2X
zJ=po9P8VU{`FrfZaHv+gLXMm<6bw0XW$SW%n}4+c2Ph6tlyj|r6TROql*rIm8bcT{
z@z#owe9{Z3(+0g^RhOPR8)7+wOz?B9;rzeq9eVvjwKb6VI?a<mEyBZl>WKhq>kO@}
zdekey2k~uFn(Vk?SEsK0dJOApO@$K1Cgv`-?M=b`?kc>G7~OG^1Z(=Ur2YLQi^jHi
z%DN{ir?X~`6S{;gCF{X=hQ1*KA_bf0-PW1RWufCjzn{fp)^pYOOh|yAyq^McXa_0v
zd0%BRLeP9A&gFT-32*+P3Y6wQck)uMH|VPxVR87s0gT#xKUnaqs#w;kbf>k+i8b0G
zvu3$SqzJm8R~0v7U@vz%RzJ?_xDhCHqn|VhUn}ugvi2-opn(wer=lp_4&H7m*-m;v
zH$Xw~D|_NkwYgS$ykC{t;6v=Qzq_-17>~V)X;r8z?8Ay<rW(0bCXUW;wL47*y8EbN
z%#1|~)49$E_<bp*aS2}}UER5MKwnb!EFLo8bs>budH!s+q)l$zJ0AEq9)m=r5{cKL
z{YN|n5(<`kBYxwC9zTT?43=^}4Ml4zab%tHN}e_vdLX$%DtwW!c*mr(Z(tZ9LfX27
zdUKx#4fC(f^X1d`KItXhf{Z$&{LaZH@(DP{|7=p13>huKGj^Gi$F_x|p8j1XL!^69
zcfrIl7kdk1KMA0K<7;C8(IQ^uC0$3(vk^_|E&wq(CZzwSg-2l~^~0*lzKd+zbW!qa
z@{?jahRSX#hBck|TzE?o#T8wf@x5vT`v3#G^QxC`E&1pIgKl2KEsh3$z9+o!nlRde
zTTAIEw$Zn8<^D>`?HqYIn;BS<s?-w(i4^L{_d!<?HYm_T@)Df$k6(&&a(eq5?!>^0
z{Wj}B1GoOcZskPe5D!2<9_1zik6~JIzuq>V*#(vB{Fr`M1pUJ!|4hznGhE;I?D`sk
z+cM}EXsE^76VM)VfqB*2cateGUgRBSw4HUjRzJ)8l;6~9tq6mV_1&y44G$^!X>tCK
zo@~>{_SNL4-dzWB{cyt@kTB4hWk&*uvUce(=9rNnFxMvP*I$7_2O4?&d`@i=9;$Kx
zGk9L{tVSkvn`!?!?w~4_iJp6^^s~QJX;An^&(g0p@GNW#PeI17IK7MC+YEEQ*{`9`
zs{ru$V^XC&AOKY|P=p`u5-suHi!u|w@T}FYlaQ0vDWmfOQM)}wlo=SF*hB3tzVpmz
zz+h|a&MncA{m_%yc#^WV_Q6#Z`#UiUax<^Mw;(^sePAJ_ZHM5zt8INqu-=h^p=+11
z55o?pZk^?Id)3ofJ}yZzir**)Y=T8OMbr|l0`<NyPV0?STijBZmMam|b~e|6J&O@t
zR$om=Nn~Kceb;0aThd^H_kfynwSRLRxG7w0#beiFDdBytBndk*nEkrspE=lx(sN0k
zqcOn&&Tny2iN^NxeODUioEu{lM*IIcToU8nMicThZTLN?O6t>8MeKo{;8|-gjS&^)
z>KtLB8_Rjm$^~zW?kTT6E+R@!`=yq~$eDn(>pPEjxd%(0E}cq*iml)&#N(_US3+Ik
z{wLXGeWb5O`}yG(f#kUXk#iWHzQ#O3EqGola>hO1(}5pMgImM{h`gs?epbWAOZEP?
z9bk@JXhR)JGO~^d0$KD`{Jq(99d?;k<!T<|;M)7>)7`3$08!V+?j4s>U3d0Ij@9cH
zqba;x@W^TEmW#L#=uEEH0-Q^p_YtIdQ?~&dt>KKK(4jio)wF)j#W^AyTyd%}w>2<h
zBA7Sdh3FkdK&^7F{L3!{Nu884TXWS#;bR708ThfjNE`#?a7`spkJ(M4yu4mt#U!n-
z0pKoo5~G8^tY0%}Mlco}7-CpX@@aomet%NDO@*K%@5;7&RUZkR3RlE@``1z;sTMWE
zLG7`^xK>lG6$*uN`tQg=mRU`*_S*iB@N`{solo@2N|IUj;D05$^JBq+rj4a$4K`8c
zTO)0^40*3?cawO<n&`mHWp*L>?b?;0a<~%-x4+xH*O*+ZcikLF6BXFjXNOrJ4{grs
zqT9K++tm56O{e7666BG6S;%bC6OXF?SU-Zr7)7^0ee^oQxOACv)Q>E{wUQrf${Oi*
zSdA1bIgif&-3<u(AI67O_IQ><w0NOqP2;o;<YmYYyX7sk30@#Xgu@S>`@~nUqnb;m
zJw)0|4J%C=vO1d5O$w#QXr>D`GXt?>H2*wZzES9qXMckP9*p=f+P(aH6g%M6=hWKi
zBU31kEHv3x+j6w3RQDm?>7v<Lsd?K3jYAhh4l|2!=%HFH`d6U^BVs(UIBkjpe7KZU
zFYCDUw(ymNGPcFK{QPt%L+&WMqwsgvdJ%ofm<KQ^#dp@_3`8$=Z$AL5>Z<M8uB{g7
zyij%fMkaSaIOyNBIT6L!<mb=%(n<YwE@v>d<!~MrP~Zz~Oryl&w9cjHO^a_RkPuOG
zfw8UAUhz6u=rmL8p-%oZ(9vC3d{$*0q5ET63nGcG-Yave3!ef&o!**W)FD@P9VF*2
zlO$WGA4@thU^yd88vAfvAgF1kS#gC*VRyO%@qL>PZp=2}()USK%6<Lt3uPid&-a%v
z3)-MxR&z#M@^2Z!f|q@n9IZN%cDHWe*T9TH-fGf)I5_9fp()~av@z0&Yd(FzU8vMt
zeeHx3tyyw?XGk^zkUUxCEjR>JfR7IGREqb@DN1e>wRTC}To-xjt<Nu1!XOvLBxR-6
z`a^G45hB!Bv&dV;lYe>NwlXlCsx<F7P*g1dSJ$*b0eVAIE#Yw|EpWzry~Y>W0G<x3
z9x}IPzILaDorhh}lCn@W1EQ?fIqx9!>6}u54tu`!c&tO?gQo};-bGYLayZpsGAv()
zFZ7wZw8T_uE7%LjHvT~(kfwq+j<3q~*GcEqHE`t-KlZo=zqg`O_{}A-y)&ptkWD-7
zMY6r6abwY+dD7*!Wmc=?-`au^7hXCJERGr<)jbgU8P^gw-tP}RMfp68Le+hs$pPP&
z<Jw8CWFi|8e$xF^v3JB*xa=5GK84>asnee`m53^P$G6N!K195lD|j#jreb-i7DCoz
z-OZ5EMt0!NcLjB(ysvGI9lRZKL%~Hk`XgV2ecze3PY(=u%&zcm$=bW6PeZ#RR3$m_
z75H&7>voA)XKw?i)?V)fu)Sv=--KT5-Po!$box%<%?sBwW~6Jq_WFz6YjahVe2wWx
z2vI%9kdjvQLz$lP%@Ju#oom9%C)W@h(}>&Dsmd4j`p5T~A}+D&QxXp4i<|esfi`yx
zTp38dG$=4U0WDCNR*O<QBhT*3&TN63d;YJ~73*+yy#BUJ=q`lBsQVDKybzf!7|0oz
zYS$L@UH@Z(A8WKHHGa}RwbJ=LIcRa@21c3z(Z=TRSUny6Zud<?&7doi;n6PhPCjsR
zIM3^6&0ouftsVu;>Ex+kC&S10>x_gg*d2!Ds3yEn$G_Q6E=RG!>Ca?E<l-keyXJM}
z^PV2iLHOhqx;B3NQ{nsU6ZSIF{uUMb^}-mLWas^mFr(iWZOeR!(A#fZpb@h?e?2Hf
z`ZFpJnkXNK6M=R9$O}{i5jJ+ydra-g%Ox-`(!SpZw_y9mq&INs4dr9LT{hy5K>BuB
zrrz*xi(8J62*4P_DAf(MNAD(w!j1r#tB|<#jb6d^o{ajh#DoApskEeL|Hw&j8PTj+
zK1PpUy3JYTr@!nzy{9(DFf4fITxS0%rBQi|QE=FrfQX+6;;cRQ8CZ?Dj2*e&7Zi!I
zhRO}48e3Z5?*NC}^w-+dm*z81n<21qlZa>(Uz!naaY{IStNV2bHV(w%dawNw(te}f
zuE6*(02j@FaQ@xr<<a~vN2nt!up;_)x`$3v+IS{R)PdS$ZR3Tws~xq@ncmY{obHEh
z7aUt5S@FyGo;MMmMP>(p`jdP<(wA02ed@wMxblb<U3XD24Fc3S1Rk&=Xe;7fWxLD#
z{1*5W_4t@yoxXtxx6@evf{GfE(s2Q}tv?|+QX;f9xBX}SaVM3b>Ko#0OQX+F`xLmw
znDDzJv1p*2e>PPst>@dC9S|w4iwXoshKVD5FBBg6JC?LLL#Q<0o{bdcz#EZ=n5<Zn
zds%>HAg0t~o)^)I%vroZp;4F?1$(2P)1Kw=S!72~6RfJ$rK^cW=h2PptqTP&P9CVX
zODMacVLE5N>JW#iY`>ulq`2oMNLj8os)(rr0S~&r`G!j3){YF=VztGCLmNEN{NX;w
znXO%S$Y+Tu$06{+L&F!}1o<)WO9Aw3TxU#L(7ON7>_ifjg?*=49BW{Mla5E(6-!ya
zhTymZx^X!B@>w^kq9Dhv)lPggcX}$(a#`a=M4UYK8$h3q&t=^`+b_`aE5`$LJm!*)
zf6v?V-f@^E4M8BFW#3m->h2XKaUTsO+JS6Nqgu6d8}3Wyxw>w?F2-$7urXv^DMqq4
zHVf{K`>@`_oVl1At$wNmA*opyT0`_qPr>^Xp}yfr-b=Ts<C4ApqqhNd6S$+Nn4Xak
zx{_}kMTg?G{H_C{YyQlnCQg`<)?9`%YgMlmM^3?b4nTCA=fmsHlV8<@!${N6(OJ9?
zh`&Hp10q`iaP7f`{CVY0Mt@k5e8waUmYVT!%kH*yRSn)^K;ot~s?`p+tssnsTp+3O
zqi_TWTdaG;9Pdl7f|iMOF*)cQWZ=!v2e~Fs1ltp<B=UZJ1nDG>^GDMs$HM=t2BGRc
zAL<%UW?Vrwto)APV%@g)_hbufk8n?NZoE3Lep#|RgP4<L&ku+D(u_~vnF2M%q08jV
zKjo!5g)f++qVOzkve`!j8grr(Io9y8q=YAzQ{=HYT(UmOu7-qtBb{%g6|vu@o8w^Z
zu2pJTQvo~3Ked&t$G5O;w5@`qgs?c-##h3d1QheHjCgg*@b!{c5E&FP@*r9gv>oHL
z0Y3MXFi%b=AV2pf0Il)OPVX*SJn=_wa6sp#6_&mdz50>Qzz-|l$pYG$yRhVprbP2H
zGXZ{|@>Kv`;)nmppX&q`1^%j#W-Np`J|id_T8I|rZc_e-M8nF6J`2vo3~2OCIGhDc
z*id6(7@aT-gnE_3ki~NzaNqxLAh1Dl-C%s;$l30uZN3Ywj{|kc>MIXStl-p#9`$Yx
ze9%C=54k0e(6|PySu^LgbqSD|Of9z-u!psQ3vEI!v;qn*%WpuiqVvL(?9yzxynh3R
z2Z`!F&A+CDJ|5gwpbzY0C4!4Y!34~;7yoDKad9DCNZqRzc$V2gOz`_}t6t5TF?d4I
zH-e9efwq;36*KuH+mU?_Wdh(y^8Dej{r|YOtROwb3oSh1XAr74g!H;Uej{^-Gbl2g
zUTVUxJ`m?8Z38q|)7?DaiM*rrxm?B{<R@(DKD-08jGdb^+dm*B>4V<^lGL>wy2bK#
z&|xok`~>_pgN6uA&IJ~!zx)7`Ll1r>Q;|a%KpCtrIz|2%-;rfX>Q`lmt;Vim8Y=LE
zPnl^9=AVm+vd2SY*oglElhliVNoP_W8%l0H3^aX-8V{k;C%8B^a;(1^dd?Dq5I_zd
z&xbZubB`$GMTOnRHmISu<}yu1azl$?c@OGU;QkQ;1ewP9>tO>k@IPcoE~L9B^x!FA
zVeqKb5q)v6loQzj&N@GBfPF&hP&sj&{()>+{9d<GQB>RYK$eYXK{C3DD5cLK)*p&O
z;gzge@@#)%52_rOYmj?Rd7ehF;%TA-KY&@AkOlEYr<-vn8`v(t*Gpc2LQ4!A<7+Zm
z_ZZ7<AAjyGY)fqN&#9S)gs-Tj+;#BoH1~P@7;v25bH>Z}8@`i{Sic*jx^nQdHe=3}
z@@aPxE|&Xi;mgw=^^UJisW&1Hf#4m$@(r;=y5r#8&v+4qc#v5ea0*YM>P0ji@)ieD
zuK=)_zm*I@?5*0;J!f#iY=AO}N(D@M!!omJx%~Brmc4I-XD_H-GM7B}jH=Muh+*vG
zn|JdT20ezMR*j+caZ7M&!I(xpMC<`#wjZ47kv0NXO{^X6o%nE1Q7LDq^RzdRSEU<+
z`?ylQ8*>;fBwk8M7>$$i&2Q8kYz;K!KkmHJ#oRb!2{PO2K&-qbjZXEbZ5H}s!9^~S
zhm?dDH6NG`Am1^~G=DWCqJs%}{=;YBe|R+&-YG0U11(B?GBU_-4)7z1N@77gT({ca
zrb6|cHA9AByNU>k{m^{Aw?OE)hxe@KI`RzyA|6UGP71s%J;(f?XNm!MbNic0D?m`N
z`e3{81zfJTlJZMoE43Q66#U7Qg+9M##Tg%frKzD&O9j!SzlW|eYgQDcn*1~|$beUT
zgcuQm?OzwE|2wk(zvm2dHcK5M)KyT%aORjl`P@i0Q~XXUV(!-KlK83{38ptVgs3MH
z<9g8YzoSc;Qb;eT-A&MVz;45Ao-JcKT`d&DWz%!>nQfM7V*94&r4z^R$A_bblLr!u
zFC0BGlHVOoO|N@rEH=I9s$aZrBjMPV@xiYZ0(WKW5knugd;tJ;(YKtffIZB{N1$=e
z7mf@<aYval{v5p<fJ8FP0yi%^Tg0<Y8yD1vvJO9!pqH%l9jtpo(A6M|VB18&r=U+H
zRjBe|u(H_Yj3NUL9w<5G883+nfCEOV&kgo~Rsh1<)#RYkQrkKJE*q;bJ3{VJQuQO3
z&4jaD*6P9Ty5a4hxo81cQ$mix&*z!R=C@fCr+&lO;peP|f}loj{RZ;0erZ~qylz|b
zx!hbjRk^cI2#3HL2JN^p)Ar9mp#Kx>0KmwR8o!=<q@Y<Zd2A9Mdyw=byBqk{-it$O
zBJnXL=T^rO5nLGm&E|1L868U|1(qe)e$bXBcQ7mR;k^r|rRseHg`(zrUV1`J9$bE(
zQ@E&4D5!CnJ?rU!esc{cR0HJ;q^cl?_0KiMI^L;*R-`63!A_Ku&3B7u2snP~Ys?A}
zC75b3c_4W_hCYP(yhk2JLZvVR{2`@YF9>yGyI8x%E7U_Sqd|o*^a~K(x`0YC2*R1n
zL9WnmLW()T-Ry4!i;iK=YMas;tpXLYD>nthlrj&AO6tF-WKDwW%ExE?;-CvaE9@!)
zKvjgHWZ;gFUhZ!M>!cJ@PYATl;<k#%ji69qH0VVf_BExf#K?;b@Jvs^t*W>XqQH*y
z`q>z76EdOSt5&A1eFieHy}uZQ#9*nTdV2Apv7B!Sd`990Z^XKW+#c5Lp0|i%PUkkK
zq#m8`6Z2;@O2{!MW)mbHd}9c2Ode>B*Fu$|4v9Jh?tFgz&?aF5jKu;PIwWE)S^=pC
zFTYF)l)g1O-iR|gI@W_lU}W;FI~ZhQlZ&}E#TpLbW`zm*->Ixq==B;-HM57=&+12N
z!s;a8lN*K<PH-bq4;?++h5HEY9JOFKaob?+;%Jt78C`}fT%7}3ro8l2+7Bd~Bffev
zI$aP?nbx-)aty0kB0%h@9tq-p3(8pOeaa_LNye@y<dO90elGxl1k)vziiO5WE=Q{O
z35Z+nKzlP7k0`w{CAcQ=aq{dl3l$wn&X$dKA|?G4IOnXL?>1V%1%j4|#&-tK4VeX;
z6Dng!RA53tzX7<9)3}e5?+cyjO4pz{_pZ_ewF>3|-x?nGvgaqI+b=uLz?)}AnJB$a
zq26`7$#4QR^hGaj|IfE+$o$qOY7Wrr2|QNiGJK>XZtqwWeN&6s&$&G>RRXD|>aQ_6
zUc*H)Ukg-pnLo{nz`;Sb3E_{7q>R$laAlrNgG>*excXlOQ^4Eg>_B+3Hnh>zM7V$n
zyJH@mk9Yze*!_3Mh9~MC&!HP3qsRO)L7bs4LWYRjrMz!zoT4;E)p`1fQ%lF~FSsf6
z`4M>W^_matCuN4A?&!AOPyNgtXp*77yqjW9p?wM9{96U7p9Rx$e&d6M=7{=N_uu2T
z`PK|hn7fU5e-{g0auM)!ZBKko<C65p5|#Q^{qrf!@EZ44Q7~*!b=-s1MFC(=!b%db
zUmg8~*O%dA&eAcu4#>MrOdDu>g>|j+;<5A^T~rDWi7aE4^~1&rOIgb~Nw_q#KNaO9
z<UHrvR^$}NdHAAuON+UpIgB$BY&L^FJ-ek}6*pj5l4#)0&Ti9pF>N!sX!GW;?jkbD
zh`y)WSL{KB#PZMLcoEt(JULHp1%YNIse?t)8y}23->V1j*qV985#x>qP1Ds}1?yx#
zOAy`?I0LcrW^ZTcNLEys2_qSb(Z?rTdiiA%r;y2mlyMB=UA*P94ej+*i#w@<%f>n<
zm%y)Sdk?QaQu=yBk2|?VlT(6N^QSaXsfCB>v9J!Ys^}qSb1~15TA*qL+YH0gldA0L
z_gyyAX}JbzRb0OV;DO`Fg%%{V1*!GiXz)s!TR{g)Yqcyi)q)r*eW$-8_7-%`EcC!J
zc<TA<RtjD2<qfzH*6Nnh#49wS4yFzn4<)Q6D9-sMu&RHKE`9TIL}ZqjXrLXb6-N~P
zk~ArYPK7-w6m*vNhQ5I2;P7<M=>NFNbm^w$*h{%1PZ(?a*rR(XhID5)L$-*x>oO;K
z`;O8Qf<uJ8M$Z30INFmfi;11&BES=Td%9FU!RC!spR7lHM<3qmtI?abMK+<SvDzsF
zwLrQJ63fjC9ZB&%f*3It0RzZXEJ;g~n5ZCE@7jaXo&HBmv&V?om^8I(g6qmhu2R#G
z`>Z(5q@C4g$Ck3av`560X#)WKZ+{iTWEYS3>VhM<2e$vp1}~cEkHxi;vpDq7406x4
zAyarr5Jx;XqLFDuPxA>u`GXpY1|0@`z7=rcIO}!oasvi%%kE|bao{95{zVyBUsmyE
ze+}K!cmAL#EI?Poj6@pCxo-@q$pPAaS?Dm|d8y44I)vw}gn%gy%!1kx<!5!8Xc3UT
z#-xsdJw|TK=~AK6m8c&p;0R4&RZbQ08Lhr3)6`=GO$z4XJjP?SD+a<^&Q?R2GAF++
znhd3Jg#Nq>XZka!<nbLbFiFrmKol+?d3lV|b+i(|5U@Je|BlL<1lXnY{Sg@5jS&5w
zl*?^}cYwqa(PS8XxbOtH&ao2rUOit0nn8-PJmTnV395BMXT|9pAgWn#ETaWIaJb?r
zNREHN`p6-Wr~F=dI>)A@QocY1ED;D!w<$j+Jp2Ql%J5f*_LIq(?(zBl#DUl2&$uD8
z@*GdF)R3fSGx0sb?^>3Km?gAiv0vs_05fyNhl2KnG4hs>6UjNo8h#1RN1n^&Zu-)`
zuy$TXyzygJWIwOiBN`_qU7#L?zY?WasKf{R=6J=Nnc4LuuzfOfz~(W(a^G3HP{{2_
zeqVZ;{V{Vl;^JU+63-a{1%`y~!<r9R`maX*=d+8;8aR-YI!dM3ph};$$gytHNVf5Q
zyuR~q5)<{gWFG_Qcx4<rm1-9Mduyw6y_amrRT(zl7_$i7*R~hEU|(3kFJ8=t?Tz6l
z(Djt)N183I@^#*qY+9J1EMKofC{SA5B5(`SCIt3C(ZlTQv;0+cy4d{~xL~(0TC^z?
zab*rJL)Yd;!<oYCA4CC>EwHv&IT?AB>FRk#6fF&NX01L0Z<vesM2@|A^X*Uj3u<YG
z{-5`S_N+H-ZMNeM2eMM3^4eC>5p6Lr5$Qp&L5E)?1IcNxGL%;imr%Qa&Iav(Ar;w=
z5dek0d7ggE=EfM^i|6Sd2Hg7;4}ij^KwOuM*9hGIDR8XFI86IUl($0blfM4xoDv<7
zIKBbvOk8|ABuT5PLx_Ciz^IP>&P$P&<%~w4M#-ACh^Bdf!*QD7>o(rJg<u*<&pKLg
zvffg#NP8T#tuijs5>&BGGSqX>)LrhA@sqMl0g12LrbjX5zy_b5dflyRyD!%)VG}V{
z+J7g$NV|hgDSF=^wRM_5&9J?1-+3?HkeIvrFiQOhFM(VC$6?6h#ohCc9J13si#zoB
zZ-tvhS}wg=`BeGf$nWA&eDl5c5Mj@f@}sg$3GVru?VP~$jD=-SfAuX7gL&E3$YW=y
zEuBG2NU;0aTgxnlPpW8gf6$>8pnkUXyk91pvz>z^Yxd1K0!rBcLVaue@ZJbDetFtB
z;V^<~|H4ppa+!j+mG&;QJp=!cFWNzwX$MM?&B)}#d+%+}(mO?M3sA=F9NKE+TU^s;
zIC^n+@O_YycUPDvYLDXVBwXgDA0xmcT|MMvU)()Sm^^xN0A1?p?eshQ-L^{HOX`@m
z8CF~rqk0%FWY-a$4}#WXfup;-`bVi2I;Hg8{j5K@-W~VrvWC=*m$PUITP*xmrdysa
ze@Slot)gCsbc9+2Z>H~n3ttwb&bhj2modjiGVDbCf%RRyB||3t+<rJmIz#jdw76Tu
z*7NuM86H#7=p8N%i1id0tmuw`xxLu>wyY!`01ed0)dq=O+^W{YD&$Z1Hx3@?9A*+1
zLBC4$L*a;QxQn~?N9RyxLtL7--xW^8S~$Z;oeOuUMeH-TY43?i5tZ%yR5d7$-F|kp
z%pPf?ZQJBp#IS{aA}Sc(1${ZuIKI?&horCjjk`J7H0YxkU0wWa2>-pcg~>c%mLjd=
z2zUL#xB@o3siKbNm#n()NZ<>iRHm=OIlgT1itUMN_^7qd#~C88bqDf0($i*u3lr=r
z=s4LX<lG3xiduV~fqE8`<Z~%W$X%IPrCy0k``iAibzF?RD+x7kEArYEUCDfB<;+pQ
z{Ww<lLpJ8>CLkkUeyvUjJP){f)u%1^h4&vTVF>G86sF3@dEY9~hi*8wyyio*Ei_yD
zxeG)kGi*20mJVMId>91btpZN?%*Rz9@RkvG!W?%+rk>QV#X6~ttkSlO87>9<qP?Gz
zFDp&!3!+t#mi3^~e#$8ZtKSa|%rRDRh12UC{dJJk?vjK<7AaUG>XEHYP%v1)tXr)p
zD6S;nbM*47*0;V00ceA%2MfyT_=gE%0*K#NiQYNNJkz<Po7+Y~lbdsU9!eu+p@9=p
zy=t~gP<ZYFP!dG!<?QJ&f2WnF1#aq(kgWsbpo5=HE-W2>PM8kTLn@djZ5cd4F?Hdh
zl-Y7tPC@51xUIz{RnNj6aU8lg8FxHvcGz>Z6HLG6t^M&Fwfy`-dE8D#$ys`#W+&*G
z{-D=5As>k|keFO@pBJ`0UM$}iJ&PMoD@;rxk|Gxqd^5l-+VXe6%aCHGTh7ZF%rl9<
zE`IIPYJC*5@@glWX8lz_Fpb|o3*X<>?-{#vFqW?`T#p$!XEFY_KcWgx(Gw;+#8Usu
z_u(_0<e9QrNel927myY8?+^Z8|LDH!Lma4DuXOHTzAt^s*Mx8=OTFKLdHlbR0~wns
z2MqV+Bumi04c14R4<Fuc^ZIC;|2__6fczAhvP^gENRfle|2ocpE+8`r*9k*jJ=rbv
z?-!j6!;NAW4rTgpllJ#(>Z&+m<j-{M=4t-z_nh)oh2eI`rFQ)HaUcW4yoCAh<P>%Y
z|M!c23Bxt*RWtebnIpdg^KX(sTQC2w7tMGFhReUe#`iCi0w4UpkIR33!2fqXF2}eD
Xo|R`l*_f)Gg8!7{Zr&)v8u|S{I?Dv~

literal 0
HcmV?d00001

diff --git a/src/protocol/aggregation/mod.rs b/src/protocol/aggregation/mod.rs
index 70e6a418f..5393bb9f1 100644
--- a/src/protocol/aggregation/mod.rs
+++ b/src/protocol/aggregation/mod.rs
@@ -148,7 +148,7 @@ where
                 let c = ctx.clone();
                 async move {
                     let equality_checks = bitwise_to_onehot(eq_ctx.clone(), i, &bk?).await?;
-                    equality_bits_times_value(&c, equality_checks, num_buckets, v?, i).await
+                    equality_bits_times_value(&c, equality_checks, num_buckets, &mut v?, i).await
                 }
             }),
     );
@@ -167,7 +167,7 @@ async fn equality_bits_times_value<F, C, S>(
     ctx: &C,
     check_bits: BitDecomposed<S>,
     num_buckets: usize,
-    value_bits: BitDecomposed<S>,
+    value_bits: &mut BitDecomposed<S>,
     record_id: usize,
 ) -> Result<Vec<S>, Error>
 where
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index c4ef2a633..4e05acbd2 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1,5 +1,6 @@
 use std::iter::{repeat, zip};
 
+use embed_doc_image::embed_doc_image;
 use futures::{stream::iter as stream_iter, TryStreamExt};
 use futures_util::{future::try_join, StreamExt};
 use ipa_macros::Step;
@@ -22,7 +23,7 @@ use crate::{
             malicious::ExtendableField, semi_honest::AdditiveShare as Replicated,
             ReplicatedSecretSharing,
         },
-        BitDecomposed, Linear as LinearSecretSharing, LinearRefOps, SharedValue,
+        BitDecomposed, Linear as LinearSecretSharing, SharedValue,
     },
     seq_join::{seq_join, seq_try_join_all},
 };
@@ -176,11 +177,6 @@ pub struct CappedAttributionOutputs {
     pub capped_attributed_trigger_value: BitDecomposed<Replicated<Gf2>>,
 }
 
-pub struct PrimeFieldAggregationInputs<F: Field> {
-    pub attributed_breakdown_key_bits: BitDecomposed<Replicated<F>>,
-    pub capped_attributed_trigger_value: Replicated<F>,
-}
-
 #[derive(Step)]
 pub enum UserNthRowStep {
     #[dynamic]
@@ -193,6 +189,18 @@ impl From<usize> for UserNthRowStep {
     }
 }
 
+#[derive(Step)]
+pub enum BinaryTreeDepthStep {
+    #[dynamic]
+    Depth(usize),
+}
+
+impl From<usize> for BinaryTreeDepthStep {
+    fn from(v: usize) -> Self {
+        Self::Depth(v)
+    }
+}
+
 #[derive(Step)]
 pub(crate) enum Step {
     BinaryValidator,
@@ -205,8 +213,8 @@ pub(crate) enum Step {
     ComputeDifferenceToCap,
     ComputedCappedAttributedTriggerValueNotSaturatedCase,
     ComputedCappedAttributedTriggerValueJustSaturatedCase,
-    ComputedAttributedBreakdownKey,
-    ComputedAttributedValue,
+    ModulusConvertBreakdownKeyBits,
+    ModulusConvertConversionValueBits,
     MoveValueToCorrectBreakdown,
 }
 
@@ -266,138 +274,6 @@ where
     rows_chunked_by_user
 }
 
-/// # Errors
-/// If there is an issue in multiplication, it will error
-pub async fn attribution_and_capping_and_aggregation<C, BK, TV, F, S, SB>(
-    sh_ctx: C,
-    input_rows: Vec<PrfShardedIpaInputRow<BK, TV>>,
-    num_saturating_sum_bits: usize,
-) -> Result<Vec<S>, Error>
-where
-    C: UpgradableContext,
-    C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F>>,
-    for<'a> &'a S: LinearRefOps<'a, S, F>,
-    C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
-    F: PrimeField + ExtendableField,
-    TV: GaloisField,
-    BK: GaloisField,
-{
-    // Call attribution_and_capping
-    let user_level_attributions: Vec<CappedAttributionOutputs> =
-        attribution_and_capping(sh_ctx.clone(), input_rows, num_saturating_sum_bits).await?;
-
-    let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
-    let prime_field_m_ctx = prime_field_validator.context();
-
-    do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
-}
-
-#[derive(Step)]
-pub enum BinaryTreeDepthStep {
-    #[dynamic]
-    Depth(usize),
-}
-
-impl From<usize> for BinaryTreeDepthStep {
-    fn from(v: usize) -> Self {
-        Self::Depth(v)
-    }
-}
-
-async fn do_aggregation<C, BK, TV, F, S>(
-    ctx: C,
-    user_level_attributions: Vec<CappedAttributionOutputs>,
-) -> Result<Vec<S>, Error>
-where
-    C: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
-    for<'a> &'a S: LinearRefOps<'a, S, F>,
-    BK: GaloisField,
-    TV: GaloisField,
-    F: PrimeField + ExtendableField,
-{
-    let num_records = user_level_attributions.len();
-    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
-        .into_iter()
-        .map(|row| {
-            (
-                row.attributed_breakdown_key_bits,
-                row.capped_attributed_trigger_value,
-            )
-        })
-        .unzip();
-
-    // convert bk
-    let converted_bks = convert_bits(
-        ctx.narrow(&Step::ComputedAttributedBreakdownKey)
-            .set_total_records(num_records),
-        stream_iter(bk_vec),
-        0..BK::BITS,
-    );
-    // convert attributed value
-    let converted_values = convert_bits(
-        ctx.narrow(&Step::ComputedAttributedValue)
-            .set_total_records(num_records),
-        stream_iter(tv_vec),
-        0..TV::BITS,
-    );
-    let large_field_value =
-        converted_values.map(|val| val.unwrap().to_additive_sharing_in_large_field());
-
-    let row_contributions_stream = converted_bks
-        .zip(large_field_value)
-        .zip(futures::stream::repeat(
-            ctx.narrow(&Step::MoveValueToCorrectBreakdown)
-                .set_total_records(num_records),
-        ))
-        .enumerate()
-        .map(|(i, ((bk_bits, cred), ctx))| {
-            let mut row_contribution = vec![cred.clone(); 1 << BK::BITS];
-            let mut step: usize = 1 << BK::BITS;
-            let record_id: RecordId = RecordId::from(i);
-            let bd_key = bk_bits.unwrap();
-            async move {
-                for (tree_depth, bit_of_bdkey) in bd_key.iter().rev().enumerate() {
-                    let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
-                    let span = step >> 1;
-                    let mut futures = vec![];
-                    for i in (0..1 << BK::BITS).step_by(step) {
-                        let bit_c = depth_c.narrow(&BitOpStep::from(i));
-
-                        if i + span < 1 << BK::BITS {
-                            let vb = row_contribution[i].multiply(bit_of_bdkey, bit_c, record_id);
-                            futures.push(vb);
-                        }
-                    }
-                    let vbs = ctx.parallel_join(futures).await?;
-
-                    for (index, vb) in vbs.into_iter().enumerate() {
-                        let left_index = index * step;
-                        let right_index = left_index + span;
-
-                        row_contribution[left_index] -= &vb;
-                        row_contribution[right_index] = vb;
-                    }
-                    step = span;
-                }
-                Ok(row_contribution)
-            }
-        });
-    let row_contributions = seq_join(ctx.active_work(), row_contributions_stream);
-    row_contributions
-        .try_fold(
-            vec![S::ZERO; 1 << BK::BITS],
-            |mut running_sums, row_contribution| async move {
-                for (i, contribution) in row_contribution.iter().enumerate() {
-                    running_sums[i] += contribution;
-                }
-                Ok(running_sums)
-            },
-        )
-        .await
-}
-
 /// Sub-protocol of the PRF-sharded IPA Protocol
 ///
 /// After the computation of the per-user PRF, addition of dummy records and shuffling,
@@ -664,6 +540,171 @@ where
     ))
 }
 
+/// This circuit expects to receive records from multiple users,
+/// but with all of the records from a given user adjacent to one another, and in time order.
+///
+/// This is a wrapper function to do attribution and capping per user followed by aggregating
+/// the results per breakdown key
+/// # Errors
+/// If there is an issue in multiplication, it will error
+pub async fn attribution_and_capping_and_aggregation<C, BK, TV, F, S, SB>(
+    sh_ctx: C,
+    input_rows: Vec<PrfShardedIpaInputRow<BK, TV>>,
+    num_saturating_sum_bits: usize,
+) -> Result<Vec<S>, Error>
+where
+    C: UpgradableContext,
+    C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F>>,
+    C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+    F: PrimeField + ExtendableField,
+    TV: GaloisField,
+    BK: GaloisField,
+{
+    let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
+    let prime_field_m_ctx = prime_field_validator.context();
+
+    let user_level_attributions: Vec<CappedAttributionOutputs> =
+        attribution_and_capping(sh_ctx, input_rows, num_saturating_sum_bits).await?;
+
+    do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
+}
+
+/// Sub-protocol of the PRF-sharded IPA Protocol
+///
+/// This function receives capped user level contributions to breakdown key buckets. It does the following
+/// 1. Convert bit-shares of breakdown keys and conversion values from binary field to prime field
+/// 2. Transform conversion value bits to additive sharing
+/// 3. Move all conversion values to corresponding breakdown key bucket
+///
+/// At the end of the function, all conversions are aggregated and placed in the appropriate breakdown key bucket
+async fn do_aggregation<C, BK, TV, F, S>(
+    ctx: C,
+    user_level_attributions: Vec<CappedAttributionOutputs>,
+) -> Result<Vec<S>, Error>
+where
+    C: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
+    BK: GaloisField,
+    TV: GaloisField,
+    F: PrimeField + ExtendableField,
+{
+    let num_records = user_level_attributions.len();
+    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
+        .into_iter()
+        .map(|row| {
+            (
+                row.attributed_breakdown_key_bits,
+                row.capped_attributed_trigger_value,
+            )
+        })
+        .unzip();
+
+    // modulus convert breakdown keys
+    let converted_bks = convert_bits(
+        ctx.narrow(&Step::ModulusConvertBreakdownKeyBits)
+            .set_total_records(num_records),
+        stream_iter(bk_vec),
+        0..BK::BITS,
+    );
+    // modulus convert attributed value
+    let converted_values = convert_bits(
+        ctx.narrow(&Step::ModulusConvertConversionValueBits)
+            .set_total_records(num_records),
+        stream_iter(tv_vec),
+        0..TV::BITS,
+    );
+
+    // tranform value bits to large field
+    let large_field_values = converted_values
+        .map(|val| BitDecomposed::to_additive_sharing_in_large_field_consuming(val.unwrap()));
+
+    // move each value to the correct bucket
+    let row_contributions_stream = converted_bks
+        .zip(large_field_values)
+        .zip(futures::stream::repeat(
+            ctx.narrow(&Step::MoveValueToCorrectBreakdown)
+                .set_total_records(num_records),
+        ))
+        .enumerate()
+        .map(|(i, ((bk_bits, value), ctx))| {
+            let record_id: RecordId = RecordId::from(i);
+            let bd_key = bk_bits.unwrap();
+            let row_contribution = vec![value.clone(); 1 << BK::BITS];
+            async move {
+                move_single_value_to_bucket::<BK, _, _, _>(ctx, record_id, bd_key, row_contribution)
+                    .await
+            }
+        });
+
+    // aggregate all row level contributions
+    let row_contributions = seq_join(ctx.active_work(), row_contributions_stream);
+    row_contributions
+        .try_fold(
+            vec![S::ZERO; 1 << BK::BITS],
+            |mut running_sums, row_contribution| async move {
+                for (i, contribution) in row_contribution.iter().enumerate() {
+                    running_sums[i] += contribution;
+                }
+                Ok(running_sums)
+            },
+        )
+        .await
+}
+
+#[embed_doc_image("tree-aggregation", "images/tree_aggregation.png")]
+/// This function moves a single value to a correct bucket using tree aggregation approach
+///
+/// Here is how it works
+/// The combined value,  [`value`] forms the root of a binary tree as follows:
+/// ![Tree propagation][tree-aggregation]
+///
+/// This value is propagated through the tree, with each subsequent iteration doubling the number of multiplications.
+/// In the first round,  r=BK-1, multiply the most significant bit ,[`bd_key`]r by the value to get [`bd_key`]r.[`value`]. From that,
+/// produce [`row_contribution`]r,0 =[`value`]-[`bd_key`]r.[`value`] and [`row_contribution`]r,1=[`bd_key`]r.[`value`].
+/// This takes the most significant bit of `bd_key` and places value in one of the two child nodes of the binary tree.
+/// At each successive round, the next most significant bit is propagated from the leaf nodes of the tree into further leaf nodes:
+/// [`row_contribution`]r+1,q,0 =[`row_contribution`]r,q - [`bd_key`]r+1.[`row_contribution`]r,q and [`row_contribution`]r+1,q,1 =[`bd_key`]r+1.[`row_contribution`]r,q.  
+/// The work of each iteration therefore doubles relative to the one preceding.
+async fn move_single_value_to_bucket<BK, C, S, F>(
+    ctx: C,
+    record_id: RecordId,
+    bd_key: BitDecomposed<S>,
+    mut row_contribution: Vec<S>,
+) -> Result<Vec<S>, Error>
+where
+    BK: GaloisField,
+    C: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
+    F: PrimeField + ExtendableField,
+{
+    let mut step: usize = 1 << BK::BITS;
+
+    for (tree_depth, bit_of_bdkey) in bd_key.iter().rev().enumerate() {
+        let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
+        let span = step >> 1;
+        let mut futures = vec![];
+        for i in (0..1 << BK::BITS).step_by(step) {
+            let bit_c = depth_c.narrow(&BitOpStep::from(i));
+
+            if i + span < 1 << BK::BITS {
+                futures.push(row_contribution[i].multiply(bit_of_bdkey, bit_c, record_id));
+            }
+        }
+        let contributions = ctx.parallel_join(futures).await?;
+
+        for (index, bdbit_contribution) in contributions.into_iter().enumerate() {
+            let left_index = index * step;
+            let right_index = left_index + span;
+
+            row_contribution[left_index] -= &bdbit_contribution;
+            row_contribution[right_index] = bdbit_contribution;
+        }
+        step = span;
+    }
+    Ok(row_contribution)
+}
+
 #[cfg(all(test, unit_test))]
 pub mod tests {
     use super::{attribution_and_capping, CappedAttributionOutputs, PrfShardedIpaInputRow};
@@ -851,7 +892,7 @@ pub mod tests {
     }
 
     #[test]
-    fn semi_honest_aggregation() {
+    fn semi_honest_aggregation_capping_attribution() {
         run(|| async move {
             let world = TestWorld::default();
 
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 44aa83238..6a3f7d28d 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -67,6 +67,18 @@ impl<S> BitDecomposed<S> {
             acc + (b * F::truncate_from(1_u128 << i))
         })
     }
+
+    // Same as above, but without the need to HRTB, as this doesn't used references
+    // but rather takes ownership over the BitDecomposed
+    pub fn to_additive_sharing_in_large_field_consuming<F>(bits: BitDecomposed<S>) -> S
+    where
+        S: LinearSecretSharing<F>,
+        F: PrimeField,
+    {
+        bits.into_iter().enumerate().fold(S::ZERO, |acc, (i, b)| {
+            acc + (b * F::truncate_from(1_u128 << i))
+        })
+    }
 }
 
 impl<S> TryFrom<Vec<S>> for BitDecomposed<S> {

From 5f8913c634626fe19f6545b46466f7387fb8e8a2 Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Tue, 3 Oct 2023 13:50:36 +0800
Subject: [PATCH 025/105] remove obsolete synthetic step generation code from
 the script

---
 ipa-macros/src/derive_step/mod.rs |  5 +++--
 scripts/collect_steps.py          | 33 -------------------------------
 src/protocol/step/steps.txt       | 24 ----------------------
 3 files changed, 3 insertions(+), 59 deletions(-)

diff --git a/ipa-macros/src/derive_step/mod.rs b/ipa-macros/src/derive_step/mod.rs
index 96b99245e..702c050b2 100644
--- a/ipa-macros/src/derive_step/mod.rs
+++ b/ipa-macros/src/derive_step/mod.rs
@@ -254,8 +254,9 @@ fn get_meta_data_for(
                 ident,
                 "ipa_macros::step expects an enum with variants that match the steps in \
             steps.txt. If you've made a change to steps, make sure to run `collect_steps.py` \
-            and replace steps.txt with the output. If the step is not a part of the protocol, \
-            consider removing it.",
+            and replace steps.txt with the output. If the step is not a part of the protocol \
+            yet, you can temporarily hide the step or the module containing the step with \
+            `#[cfg(feature = \"descriptive-gate\")]`.",
             ))
         }
         1 => {
diff --git a/scripts/collect_steps.py b/scripts/collect_steps.py
index 82f15fcc6..3768fbe07 100755
--- a/scripts/collect_steps.py
+++ b/scripts/collect_steps.py
@@ -50,22 +50,7 @@
 DEPTH_DYNAMIC_STEPS = [
     "ipa::protocol::attribution::InteractionPatternStep",
 ]
-# Same here. There are steps that are executed depending on the number of bits in the
-# used field.
-BIT_DYNAMIC_STEPS = [
-    "ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks",
-    "ipa::protocol::attribution::aggregate_credit::Step::check_times_credit",
-]
-# another one for modulus conversion
-MODULUS_CONVERSION_DYNAMIC_STEPS = [
-    "ipa::protocol::sort::SortStep::convert",
-    "ipa::protocol::attribution::AttributionStep::convert_helper_bits",
-    "ipa::protocol::boolean::solved_bits::Step::random_bits",
-    "ipa::protocol::attribution::aggregate_credit::Step::mod_conv_breakdown_key_bits",
-]
 MAXIMUM_DEPTH = 32
-MAXIMUM_BIT_LENGTH = 32
-MAXIMUM_CONVERT_BIT_LENGTH = 64
 
 
 def set_env():
@@ -82,8 +67,6 @@ def remove_root_step_name_from_line(l):
 def collect_steps(args):
     output = set()
     depth_dynamic_steps = set()
-    bit_dynamic_steps = set()
-    modulus_conversion_dynamic_steps = set()
 
     proc = subprocess.Popen(
         args=args,
@@ -111,14 +94,6 @@ def collect_steps(args):
             depth_dynamic_steps.add(remove_root_step_name_from_line(line))
             # continue without adding to the `output`. we'll generate the dynamic steps later
             continue
-        if any(s in line for s in BIT_DYNAMIC_STEPS):
-            line = re.sub(r"bit\d+", "bitX", line)
-            bit_dynamic_steps.add(remove_root_step_name_from_line(line))
-            continue
-        if any(s in line for s in MODULUS_CONVERSION_DYNAMIC_STEPS):
-            line = re.sub(r"mc\d+", "mcX", line)
-            modulus_conversion_dynamic_steps.add(remove_root_step_name_from_line(line))
-            continue
 
         output.update([remove_root_step_name_from_line(line)])
 
@@ -132,14 +107,6 @@ def collect_steps(args):
         for s in depth_dynamic_steps:
             line = re.sub(r"depthX", "depth" + str(i), s)
             output.add(line)
-    for i in range(MAXIMUM_BIT_LENGTH):
-        for s in bit_dynamic_steps:
-            line = re.sub(r"bitX", "bit" + str(i), s)
-            output.add(line)
-    for i in range(MAXIMUM_CONVERT_BIT_LENGTH):
-        for s in modulus_conversion_dynamic_steps:
-            line = re.sub(r"mcX", "mc" + str(i), s)
-            output.add(line)
 
     return output
 
diff --git a/src/protocol/step/steps.txt b/src/protocol/step/steps.txt
index b4e413464..d2bc41200 100644
--- a/src/protocol/step/steps.txt
+++ b/src/protocol/step/steps.txt
@@ -1607,14 +1607,11 @@ ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::agg
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::check_times_credit/ipa::protocol::step::BitOpStep::bit8
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::check_times_credit/ipa::protocol::step::BitOpStep::bit9
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit0
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit1
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit10
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit11
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit12
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit13
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit14
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit15
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit16
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit17
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit18
@@ -1630,13 +1627,10 @@ ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::agg
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit27
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit28
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit29
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit3
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit30
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit31
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit4
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit5
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit6
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit8
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit9
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::attribution::aggregate_credit::Step::mod_conv_breakdown_key_bits
@@ -5273,12 +5267,6 @@ ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validat
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::check_times_credit/ipa::protocol::step::BitOpStep::bit9/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::check_times_credit/ipa::protocol::step::BitOpStep::bit9/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit0
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit0/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit0/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit1
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit1/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit1/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit10
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit10/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit10/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
@@ -5294,9 +5282,6 @@ ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validat
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit14
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit14/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit14/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit15
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit15/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit15/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit16
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit16/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit16/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
@@ -5342,15 +5327,9 @@ ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validat
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit29
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit29/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit29/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit3
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit3/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit3/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit30
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit30/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit30/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit31
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit31/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit31/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit4
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit4/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit4/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
@@ -5360,9 +5339,6 @@ ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validat
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit6
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit6/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit6/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit7
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit7/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
-ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit7/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit8
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit8/ipa::protocol::basics::mul::malicious::Step::duplicate_multiply
 ipa::protocol::ipa::Step::after_convert_all_bits/ipa::protocol::context::validator::Step::malicious_protocol/ipa::protocol::attribution::aggregate_credit::Step::compute_equality_checks/ipa::protocol::step::BitOpStep::bit8/ipa::protocol::basics::mul::malicious::Step::randomness_for_validation

From 448a5b7695b8b58bbd9c2aa7faea0e3b5f030f23 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 3 Oct 2023 13:51:40 +0800
Subject: [PATCH 026/105] Removing muts and defining capacity

---
 src/protocol/aggregation/mod.rs  |  4 ++--
 src/protocol/prf_sharding/mod.rs | 15 +++++++--------
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/protocol/aggregation/mod.rs b/src/protocol/aggregation/mod.rs
index 5393bb9f1..70e6a418f 100644
--- a/src/protocol/aggregation/mod.rs
+++ b/src/protocol/aggregation/mod.rs
@@ -148,7 +148,7 @@ where
                 let c = ctx.clone();
                 async move {
                     let equality_checks = bitwise_to_onehot(eq_ctx.clone(), i, &bk?).await?;
-                    equality_bits_times_value(&c, equality_checks, num_buckets, &mut v?, i).await
+                    equality_bits_times_value(&c, equality_checks, num_buckets, v?, i).await
                 }
             }),
     );
@@ -167,7 +167,7 @@ async fn equality_bits_times_value<F, C, S>(
     ctx: &C,
     check_bits: BitDecomposed<S>,
     num_buckets: usize,
-    value_bits: &mut BitDecomposed<S>,
+    value_bits: BitDecomposed<S>,
     record_id: usize,
 ) -> Result<Vec<S>, Error>
 where
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 4e05acbd2..0e0b55304 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -630,10 +630,8 @@ where
         .map(|(i, ((bk_bits, value), ctx))| {
             let record_id: RecordId = RecordId::from(i);
             let bd_key = bk_bits.unwrap();
-            let row_contribution = vec![value.clone(); 1 << BK::BITS];
             async move {
-                move_single_value_to_bucket::<BK, _, _, _>(ctx, record_id, bd_key, row_contribution)
-                    .await
+                move_single_value_to_bucket::<BK, _, _, _>(ctx, record_id, bd_key, value).await
             }
         });
 
@@ -660,17 +658,17 @@ where
 /// ![Tree propagation][tree-aggregation]
 ///
 /// This value is propagated through the tree, with each subsequent iteration doubling the number of multiplications.
-/// In the first round,  r=BK-1, multiply the most significant bit ,[`bd_key`]r by the value to get [`bd_key`]r.[`value`]. From that,
-/// produce [`row_contribution`]r,0 =[`value`]-[`bd_key`]r.[`value`] and [`row_contribution`]r,1=[`bd_key`]r.[`value`].
+/// In the first round,  r=BK-1, multiply the most significant bit ,[`bd_key`]_r by the value to get [`bd_key`]_r.[`value`]. From that,
+/// produce [`row_contribution`]_r,0 =[`value`]-[`bd_key`]_r.[`value`] and [`row_contribution`]_r,1=[`bd_key`]_r.[`value`].
 /// This takes the most significant bit of `bd_key` and places value in one of the two child nodes of the binary tree.
 /// At each successive round, the next most significant bit is propagated from the leaf nodes of the tree into further leaf nodes:
-/// [`row_contribution`]r+1,q,0 =[`row_contribution`]r,q - [`bd_key`]r+1.[`row_contribution`]r,q and [`row_contribution`]r+1,q,1 =[`bd_key`]r+1.[`row_contribution`]r,q.  
+/// [`row_contribution`]_r+1,q,0 =[`row_contribution`]_r,q - [`bd_key`]_r+1.[`row_contribution`]_r,q and [`row_contribution`]_r+1,q,1 =[`bd_key`]_r+1.[`row_contribution`]_r,q.  
 /// The work of each iteration therefore doubles relative to the one preceding.
 async fn move_single_value_to_bucket<BK, C, S, F>(
     ctx: C,
     record_id: RecordId,
     bd_key: BitDecomposed<S>,
-    mut row_contribution: Vec<S>,
+    value: S,
 ) -> Result<Vec<S>, Error>
 where
     BK: GaloisField,
@@ -679,11 +677,12 @@ where
     F: PrimeField + ExtendableField,
 {
     let mut step: usize = 1 << BK::BITS;
+    let mut row_contribution = vec![value; 1 << BK::BITS];
 
     for (tree_depth, bit_of_bdkey) in bd_key.iter().rev().enumerate() {
         let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
         let span = step >> 1;
-        let mut futures = vec![];
+        let mut futures = Vec::with_capacity((1 << BK::BITS) / step);
         for i in (0..1 << BK::BITS).step_by(step) {
             let bit_c = depth_c.narrow(&BitOpStep::from(i));
 

From 4f1f605b539fe8752c9332dd3653ba2f9b660998 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Wed, 4 Oct 2023 00:48:47 +0800
Subject: [PATCH 027/105] Feature vector label vector dot product

---
 .../prf_sharding/feature_label_dot_product.rs | 469 ++++++++++++++++++
 src/protocol/prf_sharding/mod.rs              |   3 +
 2 files changed, 472 insertions(+)
 create mode 100644 src/protocol/prf_sharding/feature_label_dot_product.rs

diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
new file mode 100644
index 000000000..bdea62dad
--- /dev/null
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -0,0 +1,469 @@
+use futures::{stream::iter as stream_iter, TryStreamExt};
+use futures_util::future::try_join;
+use ipa_macros::Step;
+
+use crate::{
+    error::Error,
+    ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
+    protocol::{
+        basics::{SecureMul, ShareKnownValue},
+        boolean::or::or,
+        context::{Context, UpgradableContext, UpgradedContext, Validator},
+        modulus_conversion::convert_bits,
+        step::BitOpStep,
+        RecordId,
+    },
+    secret_sharing::{
+        replicated::{
+            malicious::ExtendableField, semi_honest::AdditiveShare as Replicated,
+            ReplicatedSecretSharing,
+        },
+        BitDecomposed, Linear as LinearSecretSharing,
+    },
+    seq_join::seq_try_join_all,
+};
+
+pub struct PrfShardedIpaInputRow<FV: GaloisField> {
+    prf_of_match_key: u64,
+    is_trigger_bit: Replicated<Gf2>,
+    feature_vector: Replicated<FV>,
+}
+
+struct InputsRequiredFromPrevRow {
+    ever_encountered_a_trigger_event: Replicated<Gf2>,
+    is_saturated: Replicated<Gf2>,
+}
+
+impl InputsRequiredFromPrevRow {
+    ///
+    /// This function contains the main logic for the per-user attribution circuit.
+    /// Multiple rows of data about a single user are processed in-order from newest to oldest.
+    ///
+    /// Summary:
+    /// - Last touch attribution
+    ///     - Every source event which has a subsequent trigger event receives attribution
+    /// - Per user capping
+    ///     - A cumulative count of "Source Events Receiving Attribution" is maintained
+    ///     - Bitwise addition is used, and a single bit indicates if the sum is "saturated"
+    ///     - The only available values for "cap" are powers of 2 (i.e. 1, 2, 4, 8, 16, 32, ...)
+    ///     - Prior to saturation, feature vectors of source events receiving attribution contribute to the dot-product.
+    ///     - All subsequent rows contribute zero
+    /// - Outputs
+    ///     - If a user has `N` input rows, they will generate `N-1` output rows. (The first row cannot possibly contribute any value to the output)
+    ///     - Each output row is a vector, either the feature vector or zeroes.
+    pub async fn compute_row_with_previous<C, FV>(
+        &mut self,
+        ctx: C,
+        record_id: RecordId,
+        input_row: &PrfShardedIpaInputRow<FV>,
+    ) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
+    where
+        C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+        FV: GaloisField,
+    {
+        let share_of_one = Replicated::share_known_value(&ctx, Gf2::ONE);
+        let is_source_event = &share_of_one - &input_row.is_trigger_bit;
+
+        let (ever_encountered_a_trigger_event, did_source_get_attributed) = try_join(
+            or(
+                ctx.narrow(&Step::EverEncounteredTriggerEvent),
+                record_id,
+                &input_row.is_trigger_bit,
+                &self.ever_encountered_a_trigger_event,
+            ),
+            is_source_event.multiply(
+                &self.ever_encountered_a_trigger_event,
+                ctx.narrow(&Step::DidSourceReceiveAttribution),
+                record_id,
+            ),
+        )
+        .await?;
+
+        let (updated_is_saturated, capped_label) = try_join(
+            or(
+                ctx.narrow(&Step::ComputeSaturatingSum),
+                record_id,
+                &self.is_saturated,
+                &did_source_get_attributed,
+            ),
+            did_source_get_attributed.multiply(
+                &(share_of_one - &self.is_saturated),
+                ctx.narrow(&Step::IsAttributedSourceAndPrevRowNotSaturated),
+                record_id,
+            ),
+        )
+        .await?;
+
+        let unbitpacked_feature_vector = BitDecomposed::decompose(FV::BITS, |i| {
+            input_row.feature_vector.map(|v| Gf2::truncate_from(v[i]))
+        });
+
+        let capped_attributed_feature_vector = compute_capped_feature_vector(
+            ctx.narrow(&Step::ComputedCappedFeatureVector),
+            record_id,
+            &capped_label,
+            &unbitpacked_feature_vector,
+        )
+        .await?;
+
+        self.ever_encountered_a_trigger_event = ever_encountered_a_trigger_event;
+        self.is_saturated = updated_is_saturated;
+
+        Ok(capped_attributed_feature_vector)
+    }
+}
+
+#[derive(Step)]
+pub enum UserNthRowStep {
+    #[dynamic]
+    Row(usize),
+}
+
+impl From<usize> for UserNthRowStep {
+    fn from(v: usize) -> Self {
+        Self::Row(v)
+    }
+}
+
+#[derive(Step)]
+pub(crate) enum Step {
+    BinaryValidator,
+    PrimeFieldValidator,
+    EverEncounteredTriggerEvent,
+    DidSourceReceiveAttribution,
+    ComputeSaturatingSum,
+    IsAttributedSourceAndPrevRowNotSaturated,
+    ComputedCappedFeatureVector,
+    ModulusConvertFeatureVectorBits,
+}
+
+fn compute_histogram_of_users_with_row_count<S>(rows_chunked_by_user: &[Vec<S>]) -> Vec<usize> {
+    let mut output = vec![];
+    for user_rows in rows_chunked_by_user {
+        for j in 0..user_rows.len() {
+            if j >= output.len() {
+                output.push(0);
+            }
+            output[j] += 1;
+        }
+    }
+    output
+}
+
+fn set_up_contexts<C>(root_ctx: &C, histogram: &[usize]) -> Vec<C>
+where
+    C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+{
+    let mut context_per_row_depth = Vec::with_capacity(histogram.len());
+    for (row_number, num_users_having_that_row_number) in histogram.iter().enumerate() {
+        if row_number == 0 {
+            // no multiplications needed for each user's row 0. No context needed
+        } else {
+            let ctx_for_row_number = root_ctx
+                .narrow(&UserNthRowStep::from(row_number))
+                .set_total_records(*num_users_having_that_row_number);
+            context_per_row_depth.push(ctx_for_row_number);
+        }
+    }
+    context_per_row_depth
+}
+
+fn chunk_rows_by_user<FV>(
+    input_rows: Vec<PrfShardedIpaInputRow<FV>>,
+) -> Vec<Vec<PrfShardedIpaInputRow<FV>>>
+where
+    FV: GaloisField,
+{
+    let mut rows_for_user: Vec<PrfShardedIpaInputRow<FV>> = vec![];
+
+    let mut rows_chunked_by_user = vec![];
+    for row in input_rows {
+        if rows_for_user.is_empty() || row.prf_of_match_key == rows_for_user[0].prf_of_match_key {
+            rows_for_user.push(row);
+        } else {
+            rows_chunked_by_user.push(rows_for_user);
+            rows_for_user = vec![row];
+        }
+    }
+    if !rows_for_user.is_empty() {
+        rows_chunked_by_user.push(rows_for_user);
+    }
+
+    rows_chunked_by_user
+}
+
+/// Sub-protocol of the PRF-sharded IPA Protocol
+///
+/// After the computation of the per-user PRF, addition of dummy records and shuffling,
+/// the PRF column can be revealed. After that, all of the records corresponding to a single
+/// device can be processed together.
+///
+/// This circuit expects to receive records from multiple users,
+/// but with all of the records from a given user adjacent to one another, and in time order.
+///
+/// This circuit will compute attribution, and per-user capping.
+///
+/// The output of this circuit is the input to the next stage: Aggregation.
+///
+/// # Errors
+/// Propagates errors from multiplications
+/// # Panics
+/// Propagates errors from multiplications
+pub async fn compute_feature_label_dot_product<C, FV, F, S>(
+    sh_ctx: C,
+    input_rows: Vec<PrfShardedIpaInputRow<FV>>,
+) -> Result<Vec<S>, Error>
+where
+    C: UpgradableContext,
+    C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+    C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F>>,
+    FV: GaloisField,
+    F: PrimeField + ExtendableField,
+{
+    assert!(FV::BITS > 0);
+
+    let rows_chunked_by_user = chunk_rows_by_user(input_rows);
+    let histogram = compute_histogram_of_users_with_row_count(&rows_chunked_by_user);
+    let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
+    let binary_m_ctx = binary_validator.context();
+    let mut num_users_who_encountered_row_depth = Vec::with_capacity(histogram.len());
+    let ctx_for_row_number = set_up_contexts(&binary_m_ctx, &histogram);
+    let mut futures = Vec::with_capacity(rows_chunked_by_user.len());
+    for rows_for_user in rows_chunked_by_user {
+        for i in 0..rows_for_user.len() {
+            if i >= num_users_who_encountered_row_depth.len() {
+                num_users_who_encountered_row_depth.push(0);
+            }
+            num_users_who_encountered_row_depth[i] += 1;
+        }
+
+        futures.push(evaluate_per_user_attribution_circuit(
+            &ctx_for_row_number,
+            num_users_who_encountered_row_depth
+                .iter()
+                .take(rows_for_user.len())
+                .map(|x| RecordId(x - 1))
+                .collect(),
+            rows_for_user,
+        ));
+    }
+    let outputs_chunked_by_user = seq_try_join_all(sh_ctx.active_work(), futures)
+        .await?
+        .into_iter()
+        .flatten()
+        .collect::<Vec<BitDecomposed<Replicated<Gf2>>>>();
+
+    let prime_field_validator = sh_ctx.narrow(&Step::PrimeFieldValidator).validator::<F>();
+    let prime_field_ctx = prime_field_validator.context();
+
+    // modulus convert feature vector bits
+    let converted_feature_vector_bits = convert_bits(
+        prime_field_ctx
+            .narrow(&Step::ModulusConvertFeatureVectorBits)
+            .set_total_records(outputs_chunked_by_user.len()),
+        stream_iter(outputs_chunked_by_user),
+        0..FV::BITS,
+    );
+
+    converted_feature_vector_bits
+        .try_fold(
+            vec![S::ZERO; 1 << FV::BITS],
+            |mut running_sums, row_contribution| async move {
+                for (i, contribution) in row_contribution.iter().enumerate() {
+                    running_sums[i] += contribution;
+                }
+                Ok(running_sums)
+            },
+        )
+        .await
+}
+
+async fn evaluate_per_user_attribution_circuit<C, FV>(
+    ctx_for_row_number: &[C],
+    record_id_for_each_depth: Vec<RecordId>,
+    rows_for_user: Vec<PrfShardedIpaInputRow<FV>>,
+) -> Result<Vec<BitDecomposed<Replicated<Gf2>>>, Error>
+where
+    C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+    FV: GaloisField,
+{
+    assert!(!rows_for_user.is_empty());
+    if rows_for_user.len() == 1 {
+        return Ok(Vec::new());
+    }
+    let first_row = &rows_for_user[0];
+    let mut prev_row_inputs = initialize_new_device_attribution_variables(first_row);
+
+    let mut output = Vec::with_capacity(rows_for_user.len() - 1);
+    for (i, row) in rows_for_user.iter().skip(1).enumerate() {
+        let ctx_for_this_row_depth = ctx_for_row_number[i].clone(); // no context was created for row 0
+        let record_id_for_this_row_depth = record_id_for_each_depth[i + 1]; // skip row 0
+
+        let capped_attribution_outputs = prev_row_inputs
+            .compute_row_with_previous(ctx_for_this_row_depth, record_id_for_this_row_depth, row)
+            .await?;
+
+        output.push(capped_attribution_outputs);
+    }
+
+    Ok(output)
+}
+
+///
+/// Upon encountering the first row of data from a new user (as distinguished by a different OPRF of the match key)
+/// this function encapsulates the variables that must be initialized. No communication is required for this first row.
+///
+fn initialize_new_device_attribution_variables<FV>(
+    input_row: &PrfShardedIpaInputRow<FV>,
+) -> InputsRequiredFromPrevRow
+where
+    FV: GaloisField,
+{
+    InputsRequiredFromPrevRow {
+        ever_encountered_a_trigger_event: input_row.is_trigger_bit.clone(),
+        is_saturated: Replicated::ZERO,
+    }
+}
+
+async fn compute_capped_feature_vector<C>(
+    ctx: C,
+    record_id: RecordId,
+    capped_label: &Replicated<Gf2>,
+    feature_vector: &BitDecomposed<Replicated<Gf2>>,
+) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
+where
+    C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+{
+    Ok(BitDecomposed::new(
+        ctx.parallel_join(feature_vector.iter().enumerate().map(|(i, bit)| {
+            let c1 = ctx.narrow(&BitOpStep::from(i));
+            async move { capped_label.multiply(bit, c1, record_id).await }
+        }))
+        .await?,
+    ))
+}
+
+#[cfg(all(test, unit_test))]
+pub mod tests {
+    use crate::{
+        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf32Bit},
+        protocol::prf_sharding::feature_label_dot_product::{
+            compute_feature_label_dot_product, PrfShardedIpaInputRow,
+        },
+        rand::Rng,
+        secret_sharing::{
+            replicated::semi_honest::AdditiveShare as Replicated, IntoShares, SharedValue,
+        },
+        test_executor::run,
+        test_fixture::{Reconstruct, Runner, TestWorld},
+    };
+
+    struct PreShardedAndSortedOPRFTestInput<FV: GaloisField> {
+        prf_of_match_key: u64,
+        is_trigger_bit: Gf2,
+        feature_vector: FV,
+    }
+
+    fn test_input(
+        prf_of_match_key: u64,
+        is_trigger: bool,
+        feature_vector: u32,
+    ) -> PreShardedAndSortedOPRFTestInput<Gf32Bit> {
+        let is_trigger_bit = if is_trigger { Gf2::ONE } else { Gf2::ZERO };
+
+        PreShardedAndSortedOPRFTestInput {
+            prf_of_match_key,
+            is_trigger_bit,
+            feature_vector: Gf32Bit::truncate_from(feature_vector),
+        }
+    }
+
+    impl<FV> IntoShares<PrfShardedIpaInputRow<FV>> for PreShardedAndSortedOPRFTestInput<FV>
+    where
+        FV: GaloisField + IntoShares<Replicated<FV>>,
+    {
+        fn share_with<R: Rng>(self, rng: &mut R) -> [PrfShardedIpaInputRow<FV>; 3] {
+            let PreShardedAndSortedOPRFTestInput {
+                prf_of_match_key,
+                is_trigger_bit,
+                feature_vector,
+            } = self;
+
+            let [is_trigger_bit0, is_trigger_bit1, is_trigger_bit2] =
+                is_trigger_bit.share_with(rng);
+            let [feature_vector0, feature_vector1, feature_vector2] =
+                feature_vector.share_with(rng);
+
+            [
+                PrfShardedIpaInputRow {
+                    prf_of_match_key,
+                    is_trigger_bit: is_trigger_bit0,
+                    feature_vector: feature_vector0,
+                },
+                PrfShardedIpaInputRow {
+                    prf_of_match_key,
+                    is_trigger_bit: is_trigger_bit1,
+                    feature_vector: feature_vector1,
+                },
+                PrfShardedIpaInputRow {
+                    prf_of_match_key,
+                    is_trigger_bit: is_trigger_bit2,
+                    feature_vector: feature_vector2,
+                },
+            ]
+        }
+    }
+
+    #[test]
+    fn semi_honest() {
+        run(|| async move {
+            let world = TestWorld::default();
+
+            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf32Bit>> = vec![
+                /* First User */
+                test_input(123, true, 0b0000_0000_0000_0000_0000_0000_0000_0000), // trigger
+                test_input(123, false, 0b1101_0100_1111_0001_0111_0010_1010_1011), // this source DOES receive attribution
+                test_input(123, true, 0b0000_0000_0000_0000_0000_0000_0000_0000),  // trigger
+                test_input(123, false, 0b0110_1101_0001_0100_1011_0100_1010_1001), // this source does not receive attribution (capped)
+                /* Second User */
+                test_input(234, true, 0b0000_0000_0000_0000_0000_0000_0000_0000), // trigger
+                test_input(234, false, 0b0001_1010_0011_0111_0110_0010_1111_0000), // this source DOES receive attribution
+                /* Third User */
+                test_input(345, true, 0b0000_0000_0000_0000_0000_0000_0000_0000), // trigger
+                test_input(345, true, 0b0000_0000_0000_0000_0000_0000_0000_0000), // trigger
+                test_input(345, true, 0b0000_0000_0000_0000_0000_0000_0000_0000), // trigger
+                test_input(345, true, 0b0000_0000_0000_0000_0000_0000_0000_0000), // trigger
+                test_input(345, false, 0b0111_0101_0001_0000_0111_0100_0101_0011), // this source DOES receive attribution
+                test_input(345, false, 0b1001_1000_1011_1101_0100_0110_0001_0100), // this source does not receive attribution (capped)
+                test_input(345, true, 0b0000_0000_0000_0000_0000_0000_0000_0000),  // trigger
+                test_input(345, false, 0b1000_1001_0100_0011_0111_0010_0000_1101), // this source does not receive attribution (capped)
+            ];
+
+            let expected: [u128; 32] = [
+                //     1101_0100_1111_0001_0111_0010_1010_1011
+                //     0001_1010_0011_0111_0110_0010_1111_0000
+                // +   0111_0101_0001_0000_0111_0100_0101_0011
+                // -------------------------------------------
+                //     1213_1211_1123_0112_0332_0120_2222_1022
+                1, 2, 1, 3, 1, 2, 1, 1, 1, 1, 2, 3, 0, 1, 1, 2, 0, 3, 3, 2, 0, 1, 2, 0, 2, 2, 2, 2,
+                1, 0, 2, 2,
+            ];
+
+            let result: Vec<_> = world
+                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
+                    compute_feature_label_dot_product::<
+                        _,
+                        Gf32Bit,
+                        Fp32BitPrime,
+                        Replicated<Fp32BitPrime>,
+                    >(ctx, input_rows)
+                    .await
+                    .unwrap()
+                })
+                .await
+                .reconstruct();
+            assert_eq!(result, &expected);
+        });
+    }
+}
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 0e0b55304..fdd3a6440 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -27,6 +27,9 @@ use crate::{
     },
     seq_join::{seq_join, seq_try_join_all},
 };
+
+pub mod feature_label_dot_product;
+
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {
     prf_of_match_key: u64,
     is_trigger_bit: Replicated<Gf2>,

From 094eb28346c1e5fc6d22fe09bca59f4cc6111679 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Wed, 4 Oct 2023 21:40:17 +0800
Subject: [PATCH 028/105] It doesn't really compile yet

---
 Cargo.toml                                    |  1 +
 .../prf_sharding/feature_label_dot_product.rs | 43 ++++++++++---------
 2 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index e264d503f..a72bfcfbf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -95,6 +95,7 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 typenum = "1.16"
 # hpke is pinned to it
 x25519-dalek = "2.0.0-pre.0"
+stream-flatten-iters = "0.2.0"
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 tikv-jemallocator = "0.5.0"
diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index bdea62dad..66dca764e 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -1,7 +1,9 @@
 use futures::{stream::iter as stream_iter, TryStreamExt};
-use futures_util::future::try_join;
+use futures_util::{future::try_join, StreamExt};
 use ipa_macros::Step;
 
+use stream_flatten_iters::StreamExt as _;
+
 use crate::{
     error::Error,
     ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
@@ -20,7 +22,7 @@ use crate::{
         },
         BitDecomposed, Linear as LinearSecretSharing,
     },
-    seq_join::seq_try_join_all,
+    seq_join::seq_join,
 };
 
 pub struct PrfShardedIpaInputRow<FV: GaloisField> {
@@ -223,36 +225,34 @@ where
 {
     assert!(FV::BITS > 0);
 
+    let mut num_outputs = input_rows.len();
     let rows_chunked_by_user = chunk_rows_by_user(input_rows);
+    num_outputs -= rows_chunked_by_user.len();
     let histogram = compute_histogram_of_users_with_row_count(&rows_chunked_by_user);
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
-    let mut num_users_who_encountered_row_depth = Vec::with_capacity(histogram.len());
+    let mut num_users_who_encountered_row_depth = vec![0_u32; histogram.len()];
     let ctx_for_row_number = set_up_contexts(&binary_m_ctx, &histogram);
     let mut futures = Vec::with_capacity(rows_chunked_by_user.len());
     for rows_for_user in rows_chunked_by_user {
-        for i in 0..rows_for_user.len() {
-            if i >= num_users_who_encountered_row_depth.len() {
-                num_users_who_encountered_row_depth.push(0);
-            }
-            num_users_who_encountered_row_depth[i] += 1;
-        }
-
+        let num_user_rows = rows_for_user.len();
         futures.push(evaluate_per_user_attribution_circuit(
             &ctx_for_row_number,
             num_users_who_encountered_row_depth
                 .iter()
-                .take(rows_for_user.len())
-                .map(|x| RecordId(x - 1))
+                .take(num_user_rows)
+                .map(|x| RecordId(*x))
                 .collect(),
             rows_for_user,
         ));
+        for i in 0..num_user_rows {
+            num_users_who_encountered_row_depth[i] += 1;
+        }
     }
-    let outputs_chunked_by_user = seq_try_join_all(sh_ctx.active_work(), futures)
-        .await?
-        .into_iter()
-        .flatten()
-        .collect::<Vec<BitDecomposed<Replicated<Gf2>>>>();
+
+    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_iter(futures))
+        .map(|x| x.unwrap().into_iter())
+        .flatten_iters();
 
     let prime_field_validator = sh_ctx.narrow(&Step::PrimeFieldValidator).validator::<F>();
     let prime_field_ctx = prime_field_validator.context();
@@ -261,14 +261,14 @@ where
     let converted_feature_vector_bits = convert_bits(
         prime_field_ctx
             .narrow(&Step::ModulusConvertFeatureVectorBits)
-            .set_total_records(outputs_chunked_by_user.len()),
-        stream_iter(outputs_chunked_by_user),
+            .set_total_records(num_outputs),
+        flattenned_stream,
         0..FV::BITS,
     );
 
     converted_feature_vector_bits
         .try_fold(
-            vec![S::ZERO; 1 << FV::BITS],
+            vec![S::ZERO; usize::try_from(FV::BITS).unwrap()],
             |mut running_sums, row_contribution| async move {
                 for (i, contribution) in row_contribution.iter().enumerate() {
                     running_sums[i] += contribution;
@@ -440,7 +440,7 @@ pub mod tests {
                 test_input(345, false, 0b1000_1001_0100_0011_0111_0010_0000_1101), // this source does not receive attribution (capped)
             ];
 
-            let expected: [u128; 32] = [
+            let mut expected: [u128; 32] = [
                 //     1101_0100_1111_0001_0111_0010_1010_1011
                 //     0001_1010_0011_0111_0110_0010_1111_0000
                 // +   0111_0101_0001_0000_0111_0100_0101_0011
@@ -449,6 +449,7 @@ pub mod tests {
                 1, 2, 1, 3, 1, 2, 1, 1, 1, 1, 2, 3, 0, 1, 1, 2, 0, 3, 3, 2, 0, 1, 2, 0, 2, 2, 2, 2,
                 1, 0, 2, 2,
             ];
+            expected.reverse(); // convert to little-endian order
 
             let result: Vec<_> = world
                 .semi_honest(records.into_iter(), |ctx, input_rows| async move {

From 0106fb3526a2c3aaa8a8465b55272968a1d47020 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 5 Oct 2023 08:26:08 +0800
Subject: [PATCH 029/105] Now it compiles. thank you martin

---
 .../prf_sharding/feature_label_dot_product.rs     | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index 66dca764e..3fb35835d 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -2,6 +2,8 @@ use futures::{stream::iter as stream_iter, TryStreamExt};
 use futures_util::{future::try_join, StreamExt};
 use ipa_macros::Step;
 
+use std::iter::zip;
+
 use stream_flatten_iters::StreamExt as _;
 
 use crate::{
@@ -237,7 +239,7 @@ where
     for rows_for_user in rows_chunked_by_user {
         let num_user_rows = rows_for_user.len();
         futures.push(evaluate_per_user_attribution_circuit(
-            &ctx_for_row_number,
+            ctx_for_row_number[..rows_for_user.len() - 1].to_owned(),
             num_users_who_encountered_row_depth
                 .iter()
                 .take(num_user_rows)
@@ -280,7 +282,7 @@ where
 }
 
 async fn evaluate_per_user_attribution_circuit<C, FV>(
-    ctx_for_row_number: &[C],
+    ctx_for_row_number: Vec<C>,
     record_id_for_each_depth: Vec<RecordId>,
     rows_for_user: Vec<PrfShardedIpaInputRow<FV>>,
 ) -> Result<Vec<BitDecomposed<Replicated<Gf2>>>, Error>
@@ -296,12 +298,15 @@ where
     let mut prev_row_inputs = initialize_new_device_attribution_variables(first_row);
 
     let mut output = Vec::with_capacity(rows_for_user.len() - 1);
-    for (i, row) in rows_for_user.iter().skip(1).enumerate() {
-        let ctx_for_this_row_depth = ctx_for_row_number[i].clone(); // no context was created for row 0
+    // skip the first row as it requires no multiplications
+    // no context was created for the first row
+    for (i, (row, ctx)) in
+        zip(rows_for_user.iter().skip(1), ctx_for_row_number.into_iter()).enumerate()
+    {
         let record_id_for_this_row_depth = record_id_for_each_depth[i + 1]; // skip row 0
 
         let capped_attribution_outputs = prev_row_inputs
-            .compute_row_with_previous(ctx_for_this_row_depth, record_id_for_this_row_depth, row)
+            .compute_row_with_previous(ctx, record_id_for_this_row_depth, row)
             .await?;
 
         output.push(capped_attribution_outputs);

From 9ec0e779915d6f60aad29dfd3bc6726c23af8d22 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Thu, 5 Oct 2023 11:46:57 +0800
Subject: [PATCH 030/105] Adding test for aggregation alone

---
 src/protocol/prf_sharding/mod.rs | 174 +++++++++++++++++++++++++------
 1 file changed, 145 insertions(+), 29 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 0e0b55304..91fa0aef3 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -709,14 +709,21 @@ pub mod tests {
     use super::{attribution_and_capping, CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
         ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf3Bit, Gf5Bit},
-        protocol::prf_sharding::attribution_and_capping_and_aggregation,
+        protocol::{
+            context::{Context, UpgradableContext, Validator},
+            prf_sharding::{
+                attribution_and_capping_and_aggregation, do_aggregation,
+                move_single_value_to_bucket,
+            },
+            RecordId,
+        },
         rand::Rng,
         secret_sharing::{
             replicated::semi_honest::AdditiveShare as Replicated, BitDecomposed, IntoShares,
             SharedValue,
         },
         test_executor::run,
-        test_fixture::{Reconstruct, Runner, TestWorld},
+        test_fixture::{get_bits, Reconstruct, Runner, TestWorld},
     };
 
     struct PreShardedAndSortedOPRFTestInput<BK: GaloisField, TV: GaloisField> {
@@ -742,20 +749,30 @@ pub mod tests {
         }
     }
 
-    fn test_output(
+    fn test_output<BK, TV>(
         attributed_breakdown_key: u128,
         capped_attributed_trigger_value: u128,
-    ) -> PreAggregationTestOutput {
+    ) -> PreAggregationTestOutput
+    where
+        BK: GaloisField,
+        TV: GaloisField,
+    {
         PreAggregationTestOutput {
-            attributed_breakdown_key,
-            capped_attributed_trigger_value,
+            attributed_breakdown_key: get_bits::<Gf2>(
+                attributed_breakdown_key.try_into().unwrap(),
+                BK::BITS,
+            ),
+            capped_attributed_trigger_value: get_bits::<Gf2>(
+                capped_attributed_trigger_value.try_into().unwrap(),
+                TV::BITS,
+            ),
         }
     }
 
     #[derive(Debug, PartialEq)]
     struct PreAggregationTestOutput {
-        attributed_breakdown_key: u128,
-        capped_attributed_trigger_value: u128,
+        attributed_breakdown_key: BitDecomposed<Gf2>,
+        capped_attributed_trigger_value: BitDecomposed<Gf2>,
     }
 
     impl<BK, TV> IntoShares<PrfShardedIpaInputRow<BK, TV>> for PreShardedAndSortedOPRFTestInput<BK, TV>
@@ -799,6 +816,40 @@ pub mod tests {
         }
     }
 
+    impl IntoShares<CappedAttributionOutputs> for PreAggregationTestOutput {
+        fn share_with<R: Rng>(self, rng: &mut R) -> [CappedAttributionOutputs; 3] {
+            let PreAggregationTestOutput {
+                attributed_breakdown_key,
+                capped_attributed_trigger_value,
+            } = self;
+
+            let did_trigger_get_attributed = Gf2::ONE;
+            let [attributed_breakdown_key0, attributed_breakdown_key1, attributed_breakdown_key2] =
+                attributed_breakdown_key.share_with(rng);
+            let [capped_attributed_trigger_value0, capped_attributed_trigger_value1, capped_attributed_trigger_value2] =
+                capped_attributed_trigger_value.share_with(rng);
+            let [did_trigger_get_attributed0, did_trigger_get_attributed1, did_trigger_get_attributed2] =
+                did_trigger_get_attributed.share_with(rng);
+
+            [
+                CappedAttributionOutputs {
+                    did_trigger_get_attributed: did_trigger_get_attributed0,
+                    attributed_breakdown_key_bits: attributed_breakdown_key0,
+                    capped_attributed_trigger_value: capped_attributed_trigger_value0,
+                },
+                CappedAttributionOutputs {
+                    did_trigger_get_attributed: did_trigger_get_attributed1,
+                    attributed_breakdown_key_bits: attributed_breakdown_key1,
+                    capped_attributed_trigger_value: capped_attributed_trigger_value1,
+                },
+                CappedAttributionOutputs {
+                    did_trigger_get_attributed: did_trigger_get_attributed2,
+                    attributed_breakdown_key_bits: attributed_breakdown_key2,
+                    capped_attributed_trigger_value: capped_attributed_trigger_value2,
+                },
+            ]
+        }
+    }
     impl Reconstruct<PreAggregationTestOutput> for [&CappedAttributionOutputs; 3] {
         fn reconstruct(&self) -> PreAggregationTestOutput {
             let [s0, s1, s2] = self;
@@ -820,16 +871,8 @@ pub mod tests {
             );
 
             PreAggregationTestOutput {
-                attributed_breakdown_key: attributed_breakdown_key_bits
-                    .iter()
-                    .map(Field::as_u128)
-                    .enumerate()
-                    .fold(0_u128, |acc, (i, x)| acc + (x << i)),
-                capped_attributed_trigger_value: capped_attributed_trigger_value_bits
-                    .iter()
-                    .map(Field::as_u128)
-                    .enumerate()
-                    .fold(0_u128, |acc, (i, x)| acc + (x << i)),
+                attributed_breakdown_key: attributed_breakdown_key_bits,
+                capped_attributed_trigger_value: capped_attributed_trigger_value_bits,
             }
         }
     }
@@ -860,17 +903,17 @@ pub mod tests {
             ];
 
             let expected: [PreAggregationTestOutput; 11] = [
-                test_output(17, 7),
-                test_output(20, 0),
-                test_output(20, 3),
-                test_output(12, 5),
-                test_output(20, 7),
-                test_output(18, 0),
-                test_output(12, 0),
-                test_output(12, 7),
-                test_output(12, 7),
-                test_output(12, 7),
-                test_output(12, 4),
+                test_output::<Gf5Bit, Gf3Bit>(17, 7),
+                test_output::<Gf5Bit, Gf3Bit>(20, 0),
+                test_output::<Gf5Bit, Gf3Bit>(20, 3),
+                test_output::<Gf5Bit, Gf3Bit>(12, 5),
+                test_output::<Gf5Bit, Gf3Bit>(20, 7),
+                test_output::<Gf5Bit, Gf3Bit>(18, 0),
+                test_output::<Gf5Bit, Gf3Bit>(12, 0),
+                test_output::<Gf5Bit, Gf3Bit>(12, 7),
+                test_output::<Gf5Bit, Gf3Bit>(12, 7),
+                test_output::<Gf5Bit, Gf3Bit>(12, 7),
+                test_output::<Gf5Bit, Gf3Bit>(12, 4),
             ];
             let num_saturating_bits: usize = 5;
 
@@ -940,4 +983,77 @@ pub mod tests {
             assert_eq!(result, &expected);
         });
     }
+
+    #[test]
+    fn semi_honest_aggregation() {
+        run(|| async move {
+            let world = TestWorld::default();
+
+            let records: Vec<PreAggregationTestOutput> = vec![
+                test_output::<Gf5Bit, Gf3Bit>(17, 7),
+                test_output::<Gf5Bit, Gf3Bit>(20, 0),
+                test_output::<Gf5Bit, Gf3Bit>(20, 3),
+                test_output::<Gf5Bit, Gf3Bit>(12, 5),
+                test_output::<Gf5Bit, Gf3Bit>(20, 7),
+                test_output::<Gf5Bit, Gf3Bit>(18, 0),
+                test_output::<Gf5Bit, Gf3Bit>(12, 0),
+                test_output::<Gf5Bit, Gf3Bit>(12, 7),
+                test_output::<Gf5Bit, Gf3Bit>(12, 7),
+                test_output::<Gf5Bit, Gf3Bit>(12, 7),
+                test_output::<Gf5Bit, Gf3Bit>(12, 4),
+            ];
+
+            let mut expected = [0_u128; 32];
+            expected[12] = 30;
+            expected[17] = 7;
+            expected[20] = 10;
+
+            let result: Vec<_> = world
+                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
+                    let validator = ctx.validator();
+                    let ctx = validator.context();
+                    do_aggregation::<_, Gf5Bit, Gf3Bit, Fp32BitPrime, _>(ctx, input_rows)
+                        .await
+                        .unwrap()
+                })
+                .await
+                .reconstruct();
+            assert_eq!(result, &expected);
+        });
+    }
+
+    #[test]
+    fn semi_honest_move_value_to_single_bucket() {
+        run(|| async move {
+            let world = TestWorld::default();
+
+            let breakdown_key = 5_u128;
+            let value = Fp32BitPrime::truncate_from(10_u128);
+            let mut expected = [0_u128; 8];
+            expected[5] = 10;
+
+            let result: Vec<_> = world
+                .semi_honest(
+                    (
+                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf3Bit::BITS),
+                        value,
+                    ),
+                    |ctx, (breakdown_key_share, value_share)| async move {
+                        let validator = ctx.validator();
+                        let ctx = validator.context();
+                        move_single_value_to_bucket::<Gf3Bit, _, _, Fp32BitPrime>(
+                            ctx.set_total_records(1),
+                            RecordId::from(0),
+                            breakdown_key_share,
+                            value_share,
+                        )
+                        .await
+                        .unwrap()
+                    },
+                )
+                .await
+                .reconstruct();
+            assert_eq!(result, &expected);
+        });
+    }
 }

From 346240966a00f57016bbe974b5b0addc559f3466 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Fri, 6 Oct 2023 10:28:18 +0800
Subject: [PATCH 031/105] issue with unpin

---
 .../prf_sharding/feature_label_dot_product.rs | 48 ++++++++++++-------
 1 file changed, 30 insertions(+), 18 deletions(-)

diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index 3fb35835d..32615d1cc 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -1,5 +1,5 @@
 use futures::{stream::iter as stream_iter, TryStreamExt};
-use futures_util::{future::try_join, StreamExt};
+use futures_util::{future::try_join, stream, StreamExt};
 use ipa_macros::Step;
 
 use std::iter::zip;
@@ -235,24 +235,36 @@ where
     let binary_m_ctx = binary_validator.context();
     let mut num_users_who_encountered_row_depth = vec![0_u32; histogram.len()];
     let ctx_for_row_number = set_up_contexts(&binary_m_ctx, &histogram);
-    let mut futures = Vec::with_capacity(rows_chunked_by_user.len());
-    for rows_for_user in rows_chunked_by_user {
-        let num_user_rows = rows_for_user.len();
-        futures.push(evaluate_per_user_attribution_circuit(
-            ctx_for_row_number[..rows_for_user.len() - 1].to_owned(),
-            num_users_who_encountered_row_depth
-                .iter()
-                .take(num_user_rows)
-                .map(|x| RecordId(*x))
-                .collect(),
-            rows_for_user,
-        ));
-        for i in 0..num_user_rows {
-            num_users_who_encountered_row_depth[i] += 1;
-        }
-    }
+    let stream_of_per_user_circuits = stream::unfold(
+        (
+            num_users_who_encountered_row_depth,
+            ctx_for_row_number,
+            stream_iter(rows_chunked_by_user),
+        ),
+        |state| async move {
+            let (mut count_by_row_depth, contexts, s) = state;
+            if let Some(rows_for_user) = s.next().await {
+                let num_user_rows = rows_for_user.len();
+                let yielded = evaluate_per_user_attribution_circuit(
+                    contexts[..num_user_rows - 1].to_owned(),
+                    num_users_who_encountered_row_depth
+                        .iter()
+                        .take(num_user_rows)
+                        .map(|x| RecordId(*x))
+                        .collect(),
+                    rows_for_user,
+                );
+                for i in 0..num_user_rows {
+                    count_by_row_depth[i] += 1;
+                }
+                Some((yielded, (count_by_row_depth, contexts, s)))
+            } else {
+                None
+            }
+        },
+    );
 
-    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_iter(futures))
+    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
         .map(|x| x.unwrap().into_iter())
         .flatten_iters();
 

From b28e6d75ae6eafda804dcf366a883b7dfc957d4e Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 5 Oct 2023 23:55:19 -0700
Subject: [PATCH 032/105] Fix new clippy warnings after Rust 1.73 release

---
 src/ff/prime_field.rs                         |  1 +
 src/helpers/buffers/ordering_mpsc.rs          |  6 +++++-
 src/helpers/buffers/ordering_sender.rs        |  4 ++--
 src/helpers/gateway/mod.rs                    |  2 +-
 src/helpers/prss_protocol.rs                  |  2 +-
 src/helpers/transport/stream/input.rs         |  2 ++
 src/hpke/mod.rs                               |  3 +++
 src/protocol/boolean/comparison.rs            |  2 ++
 src/protocol/boolean/random_bits_generator.rs |  2 +-
 src/protocol/context/mod.rs                   |  2 +-
 src/protocol/dp/insecure.rs                   |  1 +
 src/protocol/ipa/mod.rs                       |  1 +
 src/telemetry/stats.rs                        | 10 ++--------
 src/test_fixture/event_gen.rs                 |  1 +
 14 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/ff/prime_field.rs b/src/ff/prime_field.rs
index ae35d59ab..49962a83d 100644
--- a/src/ff/prime_field.rs
+++ b/src/ff/prime_field.rs
@@ -208,6 +208,7 @@ macro_rules! field_impl {
             proptest! {
 
                 #[test]
+                #[allow(clippy::ignored_unit_patterns)]
                 fn serde(v in 0..$field::PRIME) {
                     let field_v = $field(v);
                     let mut buf = GenericArray::default();
diff --git a/src/helpers/buffers/ordering_mpsc.rs b/src/helpers/buffers/ordering_mpsc.rs
index 1eb2bdd9b..1968e1f87 100644
--- a/src/helpers/buffers/ordering_mpsc.rs
+++ b/src/helpers/buffers/ordering_mpsc.rs
@@ -297,6 +297,8 @@ mod fixture {
 
     #[async_trait]
     impl TestSender for OrderingMpscSender<Fp32BitPrime> {
+        // I don't understand what triggers this warning, maybe https://github.com/rust-lang/rust-clippy/issues/11403
+        #[allow(clippy::ignored_unit_patterns)]
         async fn send_test(&self, i: usize) {
             self.send(
                 i,
@@ -383,7 +385,7 @@ mod unit {
         let send = async move {
             tx_a.send(0, input).await.unwrap();
         };
-        let (_, output) = join(send, rx.take_next(1)).await;
+        let ((), output) = join(send, rx.take_next(1)).await;
         assert_eq!(
             input,
             Fp31::deserialize(GenericArray::from_slice(output.as_ref().unwrap()))
@@ -506,6 +508,7 @@ mod proptests {
 
     proptest::proptest! {
         #[test]
+        #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
         fn arbitrary_size_seq(cap in 2..1000_usize) {
             let indices = (0..cap).collect::<Vec<_>>();
             tokio::runtime::Builder::new_multi_thread()
@@ -516,6 +519,7 @@ mod proptests {
         }
 
         #[test]
+        #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
         fn arbitrary_size_shuffle(indices in shuffled(), excess in 0..10_usize) {
             tokio::runtime::Builder::new_multi_thread()
                 .enable_all()
diff --git a/src/helpers/buffers/ordering_sender.rs b/src/helpers/buffers/ordering_sender.rs
index 1c490a3e9..d74a3f11b 100644
--- a/src/helpers/buffers/ordering_sender.rs
+++ b/src/helpers/buffers/ordering_sender.rs
@@ -533,7 +533,7 @@ mod test {
             values.resize_with(COUNT, || rng.gen::<Fp32BitPrime>());
 
             let sender = sender();
-            let (_, _, output) = join3(
+            let (_, (), output) = join3(
                 join_all(values.iter().enumerate().map(|(i, &v)| sender.send(i, v))),
                 sender.close(values.len()),
                 sender.as_stream().collect::<Vec<_>>(),
@@ -568,7 +568,7 @@ mod test {
             let indices = shuffle_indices(COUNT);
 
             let sender = sender();
-            let (_, _, output) = join3(
+            let (_, (), output) = join3(
                 join_all(indices.into_iter().map(|i| sender.send(i, values[i]))),
                 sender.close(values.len()),
                 sender.as_stream().collect::<Vec<_>>(),
diff --git a/src/helpers/gateway/mod.rs b/src/helpers/gateway/mod.rs
index 4a92fe31a..ead1f32dc 100644
--- a/src/helpers/gateway/mod.rs
+++ b/src/helpers/gateway/mod.rs
@@ -180,7 +180,7 @@ mod tests {
 
         let world = TestWorld::new_with(config);
         world
-            .semi_honest((), |ctx, _| async move {
+            .semi_honest((), |ctx, ()| async move {
                 let fp2_ctx = ctx.narrow("fp2").set_total_records(100);
                 let fp32_ctx = ctx.narrow("fp32").set_total_records(100);
                 let role = ctx.role();
diff --git a/src/helpers/prss_protocol.rs b/src/helpers/prss_protocol.rs
index 48a9b760e..e44fec8ed 100644
--- a/src/helpers/prss_protocol.rs
+++ b/src/helpers/prss_protocol.rs
@@ -47,7 +47,7 @@ pub async fn negotiate<T: Transport, R: RngCore + CryptoRng>(
     let (send_left_pk, send_right_pk) = ep_setup.public_keys();
     let record_id = RecordId::FIRST;
 
-    let (_, _, recv_left_pk, recv_right_pk) = try_join4(
+    let ((), (), recv_left_pk, recv_right_pk) = try_join4(
         left_sender.send(record_id, send_left_pk),
         right_sender.send(record_id, send_right_pk),
         left_receiver.receive(record_id),
diff --git a/src/helpers/transport/stream/input.rs b/src/helpers/transport/stream/input.rs
index d7dddee23..2ca6e4a22 100644
--- a/src/helpers/transport/stream/input.rs
+++ b/src/helpers/transport/stream/input.rs
@@ -712,6 +712,7 @@ mod test {
 
         proptest::proptest! {
             #[test]
+            #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
             fn test_records_stream_works_with_any_chunks(
                 (expected_bytes, chunked_bytes, _seed) in arb_expected_and_chunked_body(30, 100)
             ) {
@@ -820,6 +821,7 @@ mod test {
 
         proptest::proptest! {
             #[test]
+            #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
             fn test_delimited_stream_works_with_any_chunks(
                 (expected_items, chunked_bytes, _seed) in arb_expected_and_chunked_body(100)
             ) {
diff --git a/src/hpke/mod.rs b/src/hpke/mod.rs
index 72257f5d8..2e940f05a 100644
--- a/src/hpke/mod.rs
+++ b/src/hpke/mod.rs
@@ -359,6 +359,7 @@ mod tests {
         proptest::proptest! {
             #![proptest_config(ProptestConfig::with_cases(50))]
             #[test]
+            #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
             fn arbitrary_ct_corruption(bad_byte in 0..23_usize, bad_bit in 0..7_usize, seed: [u8; 32]) {
                 let rng = StdRng::from_seed(seed);
                 let mut suite = EncryptionSuite::new(1, rng);
@@ -372,6 +373,7 @@ mod tests {
         proptest::proptest! {
             #![proptest_config(ProptestConfig::with_cases(50))]
             #[test]
+            #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
              fn arbitrary_enc_corruption(bad_byte in 0..32_usize, bad_bit in 0..7_usize, seed: [u8; 32]) {
                 let rng = StdRng::from_seed(seed);
                 let mut suite = EncryptionSuite::new(1, rng);
@@ -416,6 +418,7 @@ mod tests {
         proptest::proptest! {
             #![proptest_config(ProptestConfig::with_cases(50))]
             #[test]
+            #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
             fn arbitrary_info_corruption(corrupted_info_field in 1..5,
                                          site_domain in "[a-z]{10}",
                                          helper_origin in "[a-z]{10}",
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 6d7360b2d..148117854 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -558,6 +558,7 @@ mod tests {
 
     proptest! {
         #[test]
+        #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
         fn gt_fp31_proptest(a in 0..Fp31::PRIME, c in 0..Fp31::PRIME) {
             type F = Fp31;
             let r = thread_rng().gen::<F>();
@@ -566,6 +567,7 @@ mod tests {
         }
 
         #[test]
+        #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
         fn gt_fp_32bit_prime_proptest(a in 0..Fp32BitPrime::PRIME, c in 0..Fp32BitPrime::PRIME) {
             type F = Fp32BitPrime;
             let r = thread_rng().gen::<F>();
diff --git a/src/protocol/boolean/random_bits_generator.rs b/src/protocol/boolean/random_bits_generator.rs
index df99f62ba..520648dee 100644
--- a/src/protocol/boolean/random_bits_generator.rs
+++ b/src/protocol/boolean/random_bits_generator.rs
@@ -147,7 +147,7 @@ mod tests {
 
         for _ in 0..OUTER {
             let v = world
-                .semi_honest((), |ctx, _| async move {
+                .semi_honest((), |ctx, ()| async move {
                     let validator = ctx.validator();
                     let ctx = validator
                         .context()
diff --git a/src/protocol/context/mod.rs b/src/protocol/context/mod.rs
index cf445ae95..48b1efec9 100644
--- a/src/protocol/context/mod.rs
+++ b/src/protocol/context/mod.rs
@@ -352,7 +352,7 @@ mod tests {
 
         let send_channel = ctx.send_channel(left_peer);
         let recv_channel = ctx.recv_channel::<F>(right_peer);
-        let (_, right_share) = try_join!(
+        let ((), right_share) = try_join!(
             send_channel.send(record_id, share.l() - l - seq_l),
             recv_channel.receive(record_id),
         )
diff --git a/src/protocol/dp/insecure.rs b/src/protocol/dp/insecure.rs
index c4bf7c5a0..a1f3a9dfe 100644
--- a/src/protocol/dp/insecure.rs
+++ b/src/protocol/dp/insecure.rs
@@ -197,6 +197,7 @@ mod test {
     proptest! {
         #![proptest_config(ProptestConfig::with_cases(50))]
         #[test]
+        #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
         fn output_differentially_private(
             rng_seed: u64,
             epsilon in 1..255_u8,
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index daa5f68f8..eca798743 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -961,6 +961,7 @@ pub mod tests {
 
         proptest! {
             #[test]
+            #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
             fn serde(timestamp in 0..u128::MAX, match_key in 0..u64::MAX, trigger_bit in 0..u128::MAX, breakdown_key in 0..u128::MAX, trigger_value in 0..u128::MAX, seed in 0..u128::MAX) {
                 serde_internal::<Fp31>(timestamp, match_key, trigger_bit, breakdown_key, trigger_value, seed);
                 serde_internal::<Fp32BitPrime>(timestamp, match_key, trigger_bit, breakdown_key, trigger_value, seed);
diff --git a/src/telemetry/stats.rs b/src/telemetry/stats.rs
index 638248f44..d8790033c 100644
--- a/src/telemetry/stats.rs
+++ b/src/telemetry/stats.rs
@@ -46,10 +46,7 @@ impl CounterDetails {
         };
         for label in key.key().labels() {
             let (label_key, label_val) = label.clone().into_parts();
-            let dimension_values = self
-                .dimensions
-                .entry(label_key)
-                .or_insert_with(HashMap::new);
+            let dimension_values = self.dimensions.entry(label_key).or_default();
 
             *dimension_values.entry(label_val).or_insert(0) += val;
         }
@@ -85,10 +82,7 @@ impl Metrics {
             if !filter_fn(labels.as_slice()) {
                 continue;
             }
-            let entry = this
-                .counters
-                .entry(key_name.clone())
-                .or_insert_with(CounterDetails::default);
+            let entry = this.counters.entry(key_name.clone()).or_default();
 
             if let Some(descr) = descr {
                 this.metric_description.insert(key_name, descr);
diff --git a/src/test_fixture/event_gen.rs b/src/test_fixture/event_gen.rs
index 5ffab9020..23f995a7e 100644
--- a/src/test_fixture/event_gen.rs
+++ b/src/test_fixture/event_gen.rs
@@ -413,6 +413,7 @@ mod tests {
 
         proptest! {
             #[test]
+            #[allow(clippy::ignored_unit_patterns)] // https://github.com/proptest-rs/proptest/issues/371
             fn iter_test(rng_seed: u64, config in arb_config(), total_events in 1_usize..2000) {
                 does_not_exceed_config_maximums(rng_seed, &config, total_events);
             }

From 1d5cace41057c42ef60c217c85dbedb061d6bfcc Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Fri, 6 Oct 2023 15:24:42 +0800
Subject: [PATCH 033/105] Adding robust

---
 src/protocol/prf_sharding/mod.rs | 82 ++++++++++++++++++++++++++------
 1 file changed, 67 insertions(+), 15 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 91fa0aef3..8beb04cfa 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -631,7 +631,8 @@ where
             let record_id: RecordId = RecordId::from(i);
             let bd_key = bk_bits.unwrap();
             async move {
-                move_single_value_to_bucket::<BK, _, _, _>(ctx, record_id, bd_key, value).await
+                move_single_value_to_bucket::<BK, _, _, _>(ctx, record_id, bd_key, value, None)
+                    .await
             }
         });
 
@@ -669,6 +670,7 @@ async fn move_single_value_to_bucket<BK, C, S, F>(
     record_id: RecordId,
     bd_key: BitDecomposed<S>,
     value: S,
+    breakdown_count: Option<usize>,
 ) -> Result<Vec<S>, Error>
 where
     BK: GaloisField,
@@ -677,16 +679,21 @@ where
     F: PrimeField + ExtendableField,
 {
     let mut step: usize = 1 << BK::BITS;
-    let mut row_contribution = vec![value; 1 << BK::BITS];
+    let total_breakdowns = match breakdown_count {
+        Some(x) => x,
+        None => 1 << BK::BITS,
+    };
+    assert!(total_breakdowns <= 1 << BK::BITS);
+    let mut row_contribution = vec![value; total_breakdowns];
 
     for (tree_depth, bit_of_bdkey) in bd_key.iter().rev().enumerate() {
         let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
         let span = step >> 1;
-        let mut futures = Vec::with_capacity((1 << BK::BITS) / step);
-        for i in (0..1 << BK::BITS).step_by(step) {
+        let mut futures = Vec::with_capacity(bd_key.len() / step);
+        for i in (0..total_breakdowns).step_by(step) {
             let bit_c = depth_c.narrow(&BitOpStep::from(i));
 
-            if i + span < 1 << BK::BITS {
+            if i + span < total_breakdowns {
                 futures.push(row_contribution[i].multiply(bit_of_bdkey, bit_c, record_id));
             }
         }
@@ -694,10 +701,11 @@ where
 
         for (index, bdbit_contribution) in contributions.into_iter().enumerate() {
             let left_index = index * step;
-            let right_index = left_index + span;
-
-            row_contribution[left_index] -= &bdbit_contribution;
-            row_contribution[right_index] = bdbit_contribution;
+            if left_index + span < total_breakdowns {
+                let right_index = left_index + span;
+                row_contribution[left_index] -= &bdbit_contribution;
+                row_contribution[right_index] = bdbit_contribution;
+            }
         }
         step = span;
     }
@@ -706,9 +714,11 @@ where
 
 #[cfg(all(test, unit_test))]
 pub mod tests {
+    use rand::thread_rng;
+
     use super::{attribution_and_capping, CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
-        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf3Bit, Gf5Bit},
+        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf3Bit, Gf5Bit, Gf8Bit},
         protocol::{
             context::{Context, UpgradableContext, Validator},
             prf_sharding::{
@@ -1026,26 +1036,68 @@ pub mod tests {
     fn semi_honest_move_value_to_single_bucket() {
         run(|| async move {
             let world = TestWorld::default();
+            let mut rng: rand::rngs::ThreadRng = thread_rng();
+
+            let breakdown_key = rng.gen_range(0..32);
+
+            let value = Fp32BitPrime::truncate_from(10_u128);
+            let mut expected = [Fp32BitPrime::truncate_from(0_u128); 32];
+            expected[breakdown_key] = value;
+
+            let result: Vec<_> = world
+                .semi_honest(
+                    (
+                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf5Bit::BITS),
+                        value,
+                    ),
+                    |ctx, (breakdown_key_share, value_share)| async move {
+                        let validator = ctx.validator();
+                        let ctx = validator.context();
+                        move_single_value_to_bucket::<Gf5Bit, _, _, Fp32BitPrime>(
+                            ctx.set_total_records(1),
+                            RecordId::from(0),
+                            breakdown_key_share,
+                            value_share,
+                            None,
+                        )
+                        .await
+                        .unwrap()
+                    },
+                )
+                .await
+                .reconstruct();
+            assert_eq!(result, &expected);
+        });
+    }
+
+    #[test]
+    fn semi_honest_move_value_to_single_bucket_not_power_two() {
+        const BREAKDOWN_COUNT: usize = 50;
+
+        run(|| async move {
+            let world = TestWorld::default();
+            let mut rng: rand::rngs::ThreadRng = thread_rng();
 
-            let breakdown_key = 5_u128;
+            let breakdown_key = rng.gen_range(0..BREAKDOWN_COUNT);
             let value = Fp32BitPrime::truncate_from(10_u128);
-            let mut expected = [0_u128; 8];
-            expected[5] = 10;
+            let mut expected = [Fp32BitPrime::truncate_from(0_u128); BREAKDOWN_COUNT];
+            expected[breakdown_key] = value;
 
             let result: Vec<_> = world
                 .semi_honest(
                     (
-                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf3Bit::BITS),
+                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf8Bit::BITS),
                         value,
                     ),
                     |ctx, (breakdown_key_share, value_share)| async move {
                         let validator = ctx.validator();
                         let ctx = validator.context();
-                        move_single_value_to_bucket::<Gf3Bit, _, _, Fp32BitPrime>(
+                        move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
                             ctx.set_total_records(1),
                             RecordId::from(0),
                             breakdown_key_share,
                             value_share,
+                            Some(BREAKDOWN_COUNT),
                         )
                         .await
                         .unwrap()

From 7a4c052208dcb51abb1064ce6f99e831a6c65b2b Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Fri, 6 Oct 2023 20:19:53 -0700
Subject: [PATCH 034/105] Relax semi-honest reveal bounds

It shouldn't require fields, semi-honest reveal works with shared values just fine.
---
 src/protocol/basics/reveal.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/protocol/basics/reveal.rs b/src/protocol/basics/reveal.rs
index 28e54a904..672c8a473 100644
--- a/src/protocol/basics/reveal.rs
+++ b/src/protocol/basics/reveal.rs
@@ -18,7 +18,7 @@ use crate::{
             malicious::{AdditiveShare as MaliciousReplicated, ExtendableField},
             semi_honest::AdditiveShare as Replicated,
         },
-        SecretSharing,
+        SecretSharing, SharedValue,
     },
 };
 
@@ -47,10 +47,10 @@ pub trait Reveal<C: Context, B: RecordBinding>: Sized {
 /// i.e. their own shares and received share.
 #[async_trait]
 #[embed_doc_image("reveal", "images/reveal.png")]
-impl<C: Context, F: Field> Reveal<C, RecordId> for Replicated<F> {
-    type Output = F;
+impl<C: Context, V: SharedValue> Reveal<C, RecordId> for Replicated<V> {
+    type Output = V;
 
-    async fn reveal<'fut>(&self, ctx: C, record_id: RecordId) -> Result<F, Error>
+    async fn reveal<'fut>(&self, ctx: C, record_id: RecordId) -> Result<V, Error>
     where
         C: 'fut,
     {

From c3c6d96c4d72074a205baf739ab022c7e8ded463 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Mon, 9 Oct 2023 14:30:17 +0800
Subject: [PATCH 035/105] It finally works now

---
 .../prf_sharding/feature_label_dot_product.rs | 133 +++++++-----------
 1 file changed, 50 insertions(+), 83 deletions(-)

diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index 32615d1cc..4f313e8e9 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -1,8 +1,8 @@
 use futures::{stream::iter as stream_iter, TryStreamExt};
-use futures_util::{future::try_join, stream, StreamExt};
+use futures_util::{future::try_join, stream::unfold, StreamExt};
 use ipa_macros::Step;
 
-use std::iter::zip;
+use std::{iter::zip, pin::pin};
 
 use stream_flatten_iters::StreamExt as _;
 
@@ -141,19 +141,6 @@ pub(crate) enum Step {
     ModulusConvertFeatureVectorBits,
 }
 
-fn compute_histogram_of_users_with_row_count<S>(rows_chunked_by_user: &[Vec<S>]) -> Vec<usize> {
-    let mut output = vec![];
-    for user_rows in rows_chunked_by_user {
-        for j in 0..user_rows.len() {
-            if j >= output.len() {
-                output.push(0);
-            }
-            output[j] += 1;
-        }
-    }
-    output
-}
-
 fn set_up_contexts<C>(root_ctx: &C, histogram: &[usize]) -> Vec<C>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
@@ -172,30 +159,6 @@ where
     context_per_row_depth
 }
 
-fn chunk_rows_by_user<FV>(
-    input_rows: Vec<PrfShardedIpaInputRow<FV>>,
-) -> Vec<Vec<PrfShardedIpaInputRow<FV>>>
-where
-    FV: GaloisField,
-{
-    let mut rows_for_user: Vec<PrfShardedIpaInputRow<FV>> = vec![];
-
-    let mut rows_chunked_by_user = vec![];
-    for row in input_rows {
-        if rows_for_user.is_empty() || row.prf_of_match_key == rows_for_user[0].prf_of_match_key {
-            rows_for_user.push(row);
-        } else {
-            rows_chunked_by_user.push(rows_for_user);
-            rows_for_user = vec![row];
-        }
-    }
-    if !rows_for_user.is_empty() {
-        rows_chunked_by_user.push(rows_for_user);
-    }
-
-    rows_chunked_by_user
-}
-
 /// Sub-protocol of the PRF-sharded IPA Protocol
 ///
 /// After the computation of the per-user PRF, addition of dummy records and shuffling,
@@ -216,6 +179,7 @@ where
 pub async fn compute_feature_label_dot_product<C, FV, F, S>(
     sh_ctx: C,
     input_rows: Vec<PrfShardedIpaInputRow<FV>>,
+    histogram: &[usize],
 ) -> Result<Vec<S>, Error>
 where
     C: UpgradableContext,
@@ -227,42 +191,40 @@ where
 {
     assert!(FV::BITS > 0);
 
-    let mut num_outputs = input_rows.len();
-    let rows_chunked_by_user = chunk_rows_by_user(input_rows);
-    num_outputs -= rows_chunked_by_user.len();
-    let histogram = compute_histogram_of_users_with_row_count(&rows_chunked_by_user);
+    let num_outputs = input_rows.len() - histogram[0];
+    let mut input_stream = stream_iter(input_rows);
+    let first_row = input_stream.next().await.unwrap();
+    let rows_chunked_by_user = unfold(Some((input_stream, first_row)), |state| async move {
+        if state.is_none() {
+            return None;
+        }
+        let (mut s, last_row) = state.unwrap();
+        let last_row_prf = last_row.prf_of_match_key;
+        let mut current_chunk = vec![last_row];
+        while let Some(row) = s.next().await {
+            if row.prf_of_match_key == last_row_prf {
+                current_chunk.push(row);
+            } else {
+                return Some((current_chunk, Some((s, row))));
+            }
+        }
+        Some((current_chunk, None))
+    });
+
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
     let mut num_users_who_encountered_row_depth = vec![0_u32; histogram.len()];
     let ctx_for_row_number = set_up_contexts(&binary_m_ctx, &histogram);
-    let stream_of_per_user_circuits = stream::unfold(
-        (
-            num_users_who_encountered_row_depth,
-            ctx_for_row_number,
-            stream_iter(rows_chunked_by_user),
-        ),
-        |state| async move {
-            let (mut count_by_row_depth, contexts, s) = state;
-            if let Some(rows_for_user) = s.next().await {
-                let num_user_rows = rows_for_user.len();
-                let yielded = evaluate_per_user_attribution_circuit(
-                    contexts[..num_user_rows - 1].to_owned(),
-                    num_users_who_encountered_row_depth
-                        .iter()
-                        .take(num_user_rows)
-                        .map(|x| RecordId(*x))
-                        .collect(),
-                    rows_for_user,
-                );
-                for i in 0..num_user_rows {
-                    count_by_row_depth[i] += 1;
-                }
-                Some((yielded, (count_by_row_depth, contexts, s)))
-            } else {
-                None
-            }
-        },
-    );
+    let stream_of_per_user_circuits = pin!(rows_chunked_by_user.then(|rows_for_user| {
+        let num_user_rows = rows_for_user.len();
+        let contexts = ctx_for_row_number[..num_user_rows - 1].to_owned();
+        let record_ids = num_users_who_encountered_row_depth[..num_user_rows].to_owned();
+
+        for i in 0..rows_for_user.len() {
+            num_users_who_encountered_row_depth[i] += 1;
+        }
+        async move { evaluate_per_user_attribution_circuit(contexts, record_ids, rows_for_user) }
+    }));
 
     let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
         .map(|x| x.unwrap().into_iter())
@@ -295,7 +257,7 @@ where
 
 async fn evaluate_per_user_attribution_circuit<C, FV>(
     ctx_for_row_number: Vec<C>,
-    record_id_for_each_depth: Vec<RecordId>,
+    record_id_for_each_depth: Vec<u32>,
     rows_for_user: Vec<PrfShardedIpaInputRow<FV>>,
 ) -> Result<Vec<BitDecomposed<Replicated<Gf2>>>, Error>
 where
@@ -315,7 +277,7 @@ where
     for (i, (row, ctx)) in
         zip(rows_for_user.iter().skip(1), ctx_for_row_number.into_iter()).enumerate()
     {
-        let record_id_for_this_row_depth = record_id_for_each_depth[i + 1]; // skip row 0
+        let record_id_for_this_row_depth = RecordId(record_id_for_each_depth[i + 1]); // skip row 0
 
         let capped_attribution_outputs = prev_row_inputs
             .compute_row_with_previous(ctx, record_id_for_this_row_depth, row)
@@ -468,16 +430,21 @@ pub mod tests {
             ];
             expected.reverse(); // convert to little-endian order
 
-            let result: Vec<_> = world
-                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
-                    compute_feature_label_dot_product::<
-                        _,
-                        Gf32Bit,
-                        Fp32BitPrime,
-                        Replicated<Fp32BitPrime>,
-                    >(ctx, input_rows)
-                    .await
-                    .unwrap()
+            let histogram = vec![3, 3, 2, 2, 1, 1, 1, 1];
+
+            let result: Vec<Fp32BitPrime> = world
+                .semi_honest(records.into_iter(), |ctx, input_rows| {
+                    let h = histogram.as_slice();
+                    async move {
+                        compute_feature_label_dot_product::<
+                            _,
+                            Gf32Bit,
+                            Fp32BitPrime,
+                            Replicated<Fp32BitPrime>,
+                        >(ctx, input_rows, h)
+                        .await
+                        .unwrap()
+                    }
                 })
                 .await
                 .reconstruct();

From 9f6b0946b93d2782126680a5c88de96d8ef4a317 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Mon, 9 Oct 2023 15:16:30 +0800
Subject: [PATCH 036/105] Cleaned up and converted everything to streams

---
 .../prf_sharding/feature_label_dot_product.rs | 101 ++++++++++++------
 1 file changed, 71 insertions(+), 30 deletions(-)

diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index 4f313e8e9..d35cc6951 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -1,5 +1,5 @@
 use futures::{stream::iter as stream_iter, TryStreamExt};
-use futures_util::{future::try_join, stream::unfold, StreamExt};
+use futures_util::{future::try_join, stream::unfold, Stream, StreamExt};
 use ipa_macros::Step;
 
 use std::{iter::zip, pin::pin};
@@ -159,6 +159,34 @@ where
     context_per_row_depth
 }
 
+///
+/// Takes an input stream of `PrfShardedIpaInputRecordRow` which is assumed to have all records with a given PRF adjacent
+/// and converts it into a stream of vectors of `PrfShardedIpaInputRecordRow` having the same PRF.
+///
+fn chunk_rows_by_user<FV, IS>(
+    input_stream: IS,
+    first_row: PrfShardedIpaInputRow<FV>,
+) -> impl Stream<Item = Vec<PrfShardedIpaInputRow<FV>>>
+where
+    FV: GaloisField,
+    IS: Stream<Item = PrfShardedIpaInputRow<FV>> + Unpin,
+{
+    unfold(Some((input_stream, first_row)), |state| async move {
+        state.as_ref()?;
+        let (mut s, last_row) = state.unwrap();
+        let last_row_prf = last_row.prf_of_match_key;
+        let mut current_chunk = vec![last_row];
+        while let Some(row) = s.next().await {
+            if row.prf_of_match_key == last_row_prf {
+                current_chunk.push(row);
+            } else {
+                return Some((current_chunk, Some((s, row))));
+            }
+        }
+        Some((current_chunk, None))
+    })
+}
+
 /// Sub-protocol of the PRF-sharded IPA Protocol
 ///
 /// After the computation of the per-user PRF, addition of dummy records and shuffling,
@@ -166,16 +194,35 @@ where
 /// device can be processed together.
 ///
 /// This circuit expects to receive records from multiple users,
-/// but with all of the records from a given user adjacent to one another, and in time order.
+/// but with all of the records from a given user adjacent to one another, and in reverse time order (most recent event comes first).
 ///
 /// This circuit will compute attribution, and per-user capping.
 ///
-/// The output of this circuit is the input to the next stage: Aggregation.
+/// After those steps, source events to which trigger events were attributed will contribute their feature vectors to an aggregate
+///
+/// The aggregate is just the sum of all the feature vectors of source events which received attribution
+///
+/// This is useful for performing logistic regression: `https://github.com/patcg-individual-drafts/ipa/blob/main/logistic_regression.md`
+///
+/// Due to limitation in our infra, it's necessary to set the total number of records each channel will ever need to process.
+/// The number of records each channel processes is a function of the distribution of number of records per user.
+/// Rather than calculate this histogram within this function (challenging to do while streaming), at present the caller must pass this in.
+///
+/// The count at a given index indicates the number of users having at least that many rows of data.
+///
+/// Example:
+///   If the input is from 3 users,
+///     - the first having 2 records
+///     - the second having 4 records
+///     - the third having 6 records
+///   Then the histogram that should be provided is:
+///     - [3, 3, 2, 2, 1, 1]
 ///
 /// # Errors
 /// Propagates errors from multiplications
 /// # Panics
 /// Propagates errors from multiplications
+#[allow(clippy::async_yields_async)]
 pub async fn compute_feature_label_dot_product<C, FV, F, S>(
     sh_ctx: C,
     input_rows: Vec<PrfShardedIpaInputRow<FV>>,
@@ -191,49 +238,42 @@ where
 {
     assert!(FV::BITS > 0);
 
+    // Get the validator and context to use for Gf2 multiplication operations
+    let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
+    let binary_m_ctx = binary_validator.context();
+
+    // Get the validator and context to use for `Z_p` operations (modulus conversion)
+    let prime_field_validator = sh_ctx.narrow(&Step::PrimeFieldValidator).validator::<F>();
+    let prime_field_ctx = prime_field_validator.context();
+
+    // Tricky hacks to work around the limitations of our current infrastructure
     let num_outputs = input_rows.len() - histogram[0];
+    let mut record_id_for_row_depth = vec![0_u32; histogram.len()];
+    let ctx_for_row_number = set_up_contexts(&binary_m_ctx, histogram);
+
+    // Chunk the incoming stream of records into stream of vectors of records with the same PRF
     let mut input_stream = stream_iter(input_rows);
     let first_row = input_stream.next().await.unwrap();
-    let rows_chunked_by_user = unfold(Some((input_stream, first_row)), |state| async move {
-        if state.is_none() {
-            return None;
-        }
-        let (mut s, last_row) = state.unwrap();
-        let last_row_prf = last_row.prf_of_match_key;
-        let mut current_chunk = vec![last_row];
-        while let Some(row) = s.next().await {
-            if row.prf_of_match_key == last_row_prf {
-                current_chunk.push(row);
-            } else {
-                return Some((current_chunk, Some((s, row))));
-            }
-        }
-        Some((current_chunk, None))
-    });
+    let rows_chunked_by_user = chunk_rows_by_user(input_stream, first_row);
 
-    let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
-    let binary_m_ctx = binary_validator.context();
-    let mut num_users_who_encountered_row_depth = vec![0_u32; histogram.len()];
-    let ctx_for_row_number = set_up_contexts(&binary_m_ctx, &histogram);
+    // Convert to a stream of async futures that represent the result of executing the per-user circuit
     let stream_of_per_user_circuits = pin!(rows_chunked_by_user.then(|rows_for_user| {
         let num_user_rows = rows_for_user.len();
         let contexts = ctx_for_row_number[..num_user_rows - 1].to_owned();
-        let record_ids = num_users_who_encountered_row_depth[..num_user_rows].to_owned();
+        let record_ids = record_id_for_row_depth[..num_user_rows].to_owned();
 
-        for i in 0..rows_for_user.len() {
-            num_users_who_encountered_row_depth[i] += 1;
+        for count in record_id_for_row_depth.iter_mut().take(rows_for_user.len()) {
+            *count += 1;
         }
         async move { evaluate_per_user_attribution_circuit(contexts, record_ids, rows_for_user) }
     }));
 
+    // Execute all of the async futures (sequentially), and flatten the result
     let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
         .map(|x| x.unwrap().into_iter())
         .flatten_iters();
 
-    let prime_field_validator = sh_ctx.narrow(&Step::PrimeFieldValidator).validator::<F>();
-    let prime_field_ctx = prime_field_validator.context();
-
-    // modulus convert feature vector bits
+    // modulus convert feature vector bits from shares in `Z_2` to shares in `Z_p`
     let converted_feature_vector_bits = convert_bits(
         prime_field_ctx
             .narrow(&Step::ModulusConvertFeatureVectorBits)
@@ -242,6 +282,7 @@ where
         0..FV::BITS,
     );
 
+    // Sum up all the vectors
     converted_feature_vector_bits
         .try_fold(
             vec![S::ZERO; usize::try_from(FV::BITS).unwrap()],

From 3ccef7bf308a1bfdf6d47385c0190eca5a5f2422 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Mon, 9 Oct 2023 15:47:20 +0800
Subject: [PATCH 037/105] clippy imports thing

---
 src/protocol/prf_sharding/feature_label_dot_product.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index d35cc6951..a326c02ef 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -1,9 +1,8 @@
+use std::{iter::zip, pin::pin};
+
 use futures::{stream::iter as stream_iter, TryStreamExt};
 use futures_util::{future::try_join, stream::unfold, Stream, StreamExt};
 use ipa_macros::Step;
-
-use std::{iter::zip, pin::pin};
-
 use stream_flatten_iters::StreamExt as _;
 
 use crate::{

From 7fd070c0f45beb8a9b3325534d1f6ae0cc1e5144 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Mon, 9 Oct 2023 16:59:19 +0800
Subject: [PATCH 038/105] Config out the compact gate stuff

---
 src/protocol/prf_sharding/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index fdd3a6440..4c950251c 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -28,6 +28,7 @@ use crate::{
     seq_join::{seq_join, seq_try_join_all},
 };
 
+#[cfg(feature = "descriptive-gate")]
 pub mod feature_label_dot_product;
 
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {

From ea9debb35dc709806f26a05da97725f8d0c6695c Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Mon, 9 Oct 2023 16:13:38 +0800
Subject: [PATCH 039/105] Incorporate feedback

---
 src/protocol/prf_sharding/mod.rs | 145 ++++++++++++-------------------
 1 file changed, 55 insertions(+), 90 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 8beb04cfa..eed74365b 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -631,8 +631,14 @@ where
             let record_id: RecordId = RecordId::from(i);
             let bd_key = bk_bits.unwrap();
             async move {
-                move_single_value_to_bucket::<BK, _, _, _>(ctx, record_id, bd_key, value, None)
-                    .await
+                move_single_value_to_bucket::<BK, _, _, _>(
+                    ctx,
+                    record_id,
+                    bd_key,
+                    value,
+                    1 << BK::BITS,
+                )
+                .await
             }
         });
 
@@ -670,7 +676,7 @@ async fn move_single_value_to_bucket<BK, C, S, F>(
     record_id: RecordId,
     bd_key: BitDecomposed<S>,
     value: S,
-    breakdown_count: Option<usize>,
+    breakdown_count: usize,
 ) -> Result<Vec<S>, Error>
 where
     BK: GaloisField,
@@ -679,21 +685,18 @@ where
     F: PrimeField + ExtendableField,
 {
     let mut step: usize = 1 << BK::BITS;
-    let total_breakdowns = match breakdown_count {
-        Some(x) => x,
-        None => 1 << BK::BITS,
-    };
-    assert!(total_breakdowns <= 1 << BK::BITS);
-    let mut row_contribution = vec![value; total_breakdowns];
+
+    assert!(breakdown_count <= 1 << BK::BITS);
+    let mut row_contribution = vec![value; breakdown_count];
 
     for (tree_depth, bit_of_bdkey) in bd_key.iter().rev().enumerate() {
         let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
         let span = step >> 1;
-        let mut futures = Vec::with_capacity(bd_key.len() / step);
-        for i in (0..total_breakdowns).step_by(step) {
+        let mut futures = Vec::with_capacity(breakdown_count / step);
+        for i in (0..breakdown_count).step_by(step) {
             let bit_c = depth_c.narrow(&BitOpStep::from(i));
 
-            if i + span < total_breakdowns {
+            if i + span < breakdown_count {
                 futures.push(row_contribution[i].multiply(bit_of_bdkey, bit_c, record_id));
             }
         }
@@ -701,11 +704,9 @@ where
 
         for (index, bdbit_contribution) in contributions.into_iter().enumerate() {
             let left_index = index * step;
-            if left_index + span < total_breakdowns {
-                let right_index = left_index + span;
-                row_contribution[left_index] -= &bdbit_contribution;
-                row_contribution[right_index] = bdbit_contribution;
-            }
+            let right_index = left_index + span;
+            row_contribution[left_index] -= &bdbit_contribution;
+            row_contribution[right_index] = bdbit_contribution;
         }
         step = span;
     }
@@ -1034,78 +1035,42 @@ pub mod tests {
 
     #[test]
     fn semi_honest_move_value_to_single_bucket() {
-        run(|| async move {
-            let world = TestWorld::default();
-            let mut rng: rand::rngs::ThreadRng = thread_rng();
-
-            let breakdown_key = rng.gen_range(0..32);
-
-            let value = Fp32BitPrime::truncate_from(10_u128);
-            let mut expected = [Fp32BitPrime::truncate_from(0_u128); 32];
-            expected[breakdown_key] = value;
-
-            let result: Vec<_> = world
-                .semi_honest(
-                    (
-                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf5Bit::BITS),
-                        value,
-                    ),
-                    |ctx, (breakdown_key_share, value_share)| async move {
-                        let validator = ctx.validator();
-                        let ctx = validator.context();
-                        move_single_value_to_bucket::<Gf5Bit, _, _, Fp32BitPrime>(
-                            ctx.set_total_records(1),
-                            RecordId::from(0),
-                            breakdown_key_share,
-                            value_share,
-                            None,
-                        )
-                        .await
-                        .unwrap()
-                    },
-                )
-                .await
-                .reconstruct();
-            assert_eq!(result, &expected);
-        });
-    }
-
-    #[test]
-    fn semi_honest_move_value_to_single_bucket_not_power_two() {
-        const BREAKDOWN_COUNT: usize = 50;
-
-        run(|| async move {
-            let world = TestWorld::default();
-            let mut rng: rand::rngs::ThreadRng = thread_rng();
-
-            let breakdown_key = rng.gen_range(0..BREAKDOWN_COUNT);
-            let value = Fp32BitPrime::truncate_from(10_u128);
-            let mut expected = [Fp32BitPrime::truncate_from(0_u128); BREAKDOWN_COUNT];
-            expected[breakdown_key] = value;
-
-            let result: Vec<_> = world
-                .semi_honest(
-                    (
-                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf8Bit::BITS),
-                        value,
-                    ),
-                    |ctx, (breakdown_key_share, value_share)| async move {
-                        let validator = ctx.validator();
-                        let ctx = validator.context();
-                        move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
-                            ctx.set_total_records(1),
-                            RecordId::from(0),
-                            breakdown_key_share,
-                            value_share,
-                            Some(BREAKDOWN_COUNT),
-                        )
-                        .await
-                        .unwrap()
-                    },
-                )
-                .await
-                .reconstruct();
-            assert_eq!(result, &expected);
-        });
+        const MAX_BREAKDOWN_COUNT: usize = 63;
+        for _ in 1..10 {
+            run(|| async move {
+                let world = TestWorld::default();
+                let mut rng: rand::rngs::ThreadRng = thread_rng();
+                let count = rng.gen_range(1..MAX_BREAKDOWN_COUNT);
+                let breakdown_key = rng.gen_range(0..count);
+
+                let value = Fp32BitPrime::truncate_from(10_u128);
+                let mut expected = vec![Fp32BitPrime::truncate_from(0_u128); count];
+                expected[breakdown_key] = value;
+
+                let breakdown_key_bits =
+                    get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf8Bit::BITS);
+
+                let result: Vec<_> = world
+                    .semi_honest(
+                        (breakdown_key_bits, value),
+                        |ctx, (breakdown_key_share, value_share)| async move {
+                            let validator = ctx.validator();
+                            let ctx = validator.context();
+                            move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
+                                ctx.set_total_records(1),
+                                RecordId::from(0),
+                                breakdown_key_share,
+                                value_share,
+                                count,
+                            )
+                            .await
+                            .unwrap()
+                        },
+                    )
+                    .await
+                    .reconstruct();
+                assert_eq!(result, expected);
+            });
+        }
     }
 }

From 38fc761a545f4d154f077f1e85e84148766b3055 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 10 Oct 2023 12:25:46 +0800
Subject: [PATCH 040/105] move bucket can now handle upto breakdown = 127

---
 src/protocol/prf_sharding/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index eed74365b..9b572280b 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -693,8 +693,8 @@ where
         let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
         let span = step >> 1;
         let mut futures = Vec::with_capacity(breakdown_count / step);
-        for i in (0..breakdown_count).step_by(step) {
-            let bit_c = depth_c.narrow(&BitOpStep::from(i));
+        for (step_no, i) in (0..breakdown_count).step_by(step).enumerate() {
+            let bit_c = depth_c.narrow(&BitOpStep::from(step_no));
 
             if i + span < breakdown_count {
                 futures.push(row_contribution[i].multiply(bit_of_bdkey, bit_c, record_id));
@@ -1035,7 +1035,7 @@ pub mod tests {
 
     #[test]
     fn semi_honest_move_value_to_single_bucket() {
-        const MAX_BREAKDOWN_COUNT: usize = 63;
+        const MAX_BREAKDOWN_COUNT: usize = 127;
         for _ in 1..10 {
             run(|| async move {
                 let world = TestWorld::default();

From 7ca5813e69750419944466b2daf1004db6f48c52 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Tue, 10 Oct 2023 15:34:56 +0800
Subject: [PATCH 041/105] comments from Alex

---
 Cargo.toml                                    |  1 -
 .../prf_sharding/feature_label_dot_product.rs | 24 +++++++++++--------
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index a72bfcfbf..e264d503f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -95,7 +95,6 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 typenum = "1.16"
 # hpke is pinned to it
 x25519-dalek = "2.0.0-pre.0"
-stream-flatten-iters = "0.2.0"
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 tikv-jemallocator = "0.5.0"
diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index a326c02ef..0dfc28f3a 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -3,7 +3,6 @@ use std::{iter::zip, pin::pin};
 use futures::{stream::iter as stream_iter, TryStreamExt};
 use futures_util::{future::try_join, stream::unfold, Stream, StreamExt};
 use ipa_macros::Step;
-use stream_flatten_iters::StreamExt as _;
 
 use crate::{
     error::Error,
@@ -171,8 +170,7 @@ where
     IS: Stream<Item = PrfShardedIpaInputRow<FV>> + Unpin,
 {
     unfold(Some((input_stream, first_row)), |state| async move {
-        state.as_ref()?;
-        let (mut s, last_row) = state.unwrap();
+        let (mut s, last_row) = state?;
         let last_row_prf = last_row.prf_of_match_key;
         let mut current_chunk = vec![last_row];
         while let Some(row) = s.next().await {
@@ -221,7 +219,6 @@ where
 /// Propagates errors from multiplications
 /// # Panics
 /// Propagates errors from multiplications
-#[allow(clippy::async_yields_async)]
 pub async fn compute_feature_label_dot_product<C, FV, F, S>(
     sh_ctx: C,
     input_rows: Vec<PrfShardedIpaInputRow<FV>>,
@@ -252,7 +249,11 @@ where
 
     // Chunk the incoming stream of records into stream of vectors of records with the same PRF
     let mut input_stream = stream_iter(input_rows);
-    let first_row = input_stream.next().await.unwrap();
+    let first_row = input_stream.next().await;
+    if first_row.is_none() {
+        return Ok(vec![]);
+    }
+    let first_row = first_row.unwrap();
     let rows_chunked_by_user = chunk_rows_by_user(input_stream, first_row);
 
     // Convert to a stream of async futures that represent the result of executing the per-user circuit
@@ -261,16 +262,19 @@ where
         let contexts = ctx_for_row_number[..num_user_rows - 1].to_owned();
         let record_ids = record_id_for_row_depth[..num_user_rows].to_owned();
 
-        for count in record_id_for_row_depth.iter_mut().take(rows_for_user.len()) {
+        for count in &mut record_id_for_row_depth[..num_user_rows] {
             *count += 1;
         }
-        async move { evaluate_per_user_attribution_circuit(contexts, record_ids, rows_for_user) }
+        #[allow(clippy::async_yields_async)]
+        // this is ok, because seq join wants a stream of futures
+        async move {
+            evaluate_per_user_attribution_circuit(contexts, record_ids, rows_for_user)
+        }
     }));
 
     // Execute all of the async futures (sequentially), and flatten the result
     let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
-        .map(|x| x.unwrap().into_iter())
-        .flatten_iters();
+        .flat_map(|x| stream_iter(x.unwrap()));
 
     // modulus convert feature vector bits from shares in `Z_2` to shares in `Z_p`
     let converted_feature_vector_bits = convert_bits(
@@ -317,7 +321,7 @@ where
     for (i, (row, ctx)) in
         zip(rows_for_user.iter().skip(1), ctx_for_row_number.into_iter()).enumerate()
     {
-        let record_id_for_this_row_depth = RecordId(record_id_for_each_depth[i + 1]); // skip row 0
+        let record_id_for_this_row_depth = RecordId::from(record_id_for_each_depth[i + 1]); // skip row 0
 
         let capped_attribution_outputs = prev_row_inputs
             .compute_row_with_previous(ctx, record_id_for_this_row_depth, row)

From 0751e18e3398865d689456450f32c3c011435942 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 10 Oct 2023 22:01:16 +0800
Subject: [PATCH 042/105] add robust + testcase for it

---
 src/protocol/prf_sharding/mod.rs | 232 +++++++++++++++++++++----------
 1 file changed, 157 insertions(+), 75 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 9b572280b..61fae9663 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -637,6 +637,7 @@ where
                     bd_key,
                     value,
                     1 << BK::BITS,
+                    false,
                 )
                 .await
             }
@@ -671,12 +672,18 @@ where
 /// At each successive round, the next most significant bit is propagated from the leaf nodes of the tree into further leaf nodes:
 /// [`row_contribution`]_r+1,q,0 =[`row_contribution`]_r,q - [`bd_key`]_r+1.[`row_contribution`]_r,q and [`row_contribution`]_r+1,q,1 =[`bd_key`]_r+1.[`row_contribution`]_r,q.  
 /// The work of each iteration therefore doubles relative to the one preceding.
+///
+/// In case a malicious entity sends a out of range breakdown key (i.e. greater than the max count) to this function, we need to do some
+/// extra processing to ensure contribution doesn't end up in a wrong bucket. However, this requires extra multiplications.
+/// This would potentially not be needed in IPA (as aggregation is done after pre-processing which should be able to throw such input) but useful for PAM.
+/// This can be by passing `robust_for_breakdown_key_gt_count as true
 async fn move_single_value_to_bucket<BK, C, S, F>(
     ctx: C,
     record_id: RecordId,
     bd_key: BitDecomposed<S>,
     value: S,
     breakdown_count: usize,
+    robust_for_breakdown_key_gt_count: bool,
 ) -> Result<Vec<S>, Error>
 where
     BK: GaloisField,
@@ -693,11 +700,12 @@ where
         let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
         let span = step >> 1;
         let mut futures = Vec::with_capacity(breakdown_count / step);
-        for (step_no, i) in (0..breakdown_count).step_by(step).enumerate() {
-            let bit_c = depth_c.narrow(&BitOpStep::from(step_no));
 
-            if i + span < breakdown_count {
-                futures.push(row_contribution[i].multiply(bit_of_bdkey, bit_c, record_id));
+        for (i, tree_index) in (0..breakdown_count).step_by(step).enumerate() {
+            let bit_c = depth_c.narrow(&BitOpStep::from(i));
+
+            if robust_for_breakdown_key_gt_count || tree_index + span < breakdown_count {
+                futures.push(row_contribution[tree_index].multiply(bit_of_bdkey, bit_c, record_id));
             }
         }
         let contributions = ctx.parallel_join(futures).await?;
@@ -705,8 +713,11 @@ where
         for (index, bdbit_contribution) in contributions.into_iter().enumerate() {
             let left_index = index * step;
             let right_index = left_index + span;
+
             row_contribution[left_index] -= &bdbit_contribution;
-            row_contribution[right_index] = bdbit_contribution;
+            if right_index < breakdown_count {
+                row_contribution[right_index] = bdbit_contribution;
+            }
         }
         step = span;
     }
@@ -744,7 +755,7 @@ pub mod tests {
         trigger_value: TV,
     }
 
-    fn test_input(
+    fn oprf_test_input(
         prf_of_match_key: u64,
         is_trigger: bool,
         breakdown_key: u8,
@@ -760,15 +771,15 @@ pub mod tests {
         }
     }
 
-    fn test_output<BK, TV>(
+    fn bitwise_bd_key_and_value<BK, TV>(
         attributed_breakdown_key: u128,
         capped_attributed_trigger_value: u128,
-    ) -> PreAggregationTestOutput
+    ) -> PreAggregationTestInputInBits
     where
         BK: GaloisField,
         TV: GaloisField,
     {
-        PreAggregationTestOutput {
+        PreAggregationTestInputInBits {
             attributed_breakdown_key: get_bits::<Gf2>(
                 attributed_breakdown_key.try_into().unwrap(),
                 BK::BITS,
@@ -780,8 +791,24 @@ pub mod tests {
         }
     }
 
+    fn decimal_bd_key_and_value(
+        attributed_breakdown_key: u128,
+        capped_attributed_trigger_value: u128,
+    ) -> PreAggregationTestOutputInDecimal {
+        PreAggregationTestOutputInDecimal {
+            attributed_breakdown_key,
+            capped_attributed_trigger_value,
+        }
+    }
+
+    #[derive(Debug, PartialEq)]
+    struct PreAggregationTestOutputInDecimal {
+        attributed_breakdown_key: u128,
+        capped_attributed_trigger_value: u128,
+    }
+
     #[derive(Debug, PartialEq)]
-    struct PreAggregationTestOutput {
+    struct PreAggregationTestInputInBits {
         attributed_breakdown_key: BitDecomposed<Gf2>,
         capped_attributed_trigger_value: BitDecomposed<Gf2>,
     }
@@ -827,9 +854,9 @@ pub mod tests {
         }
     }
 
-    impl IntoShares<CappedAttributionOutputs> for PreAggregationTestOutput {
+    impl IntoShares<CappedAttributionOutputs> for PreAggregationTestInputInBits {
         fn share_with<R: Rng>(self, rng: &mut R) -> [CappedAttributionOutputs; 3] {
-            let PreAggregationTestOutput {
+            let PreAggregationTestInputInBits {
                 attributed_breakdown_key,
                 capped_attributed_trigger_value,
             } = self;
@@ -861,10 +888,10 @@ pub mod tests {
             ]
         }
     }
-    impl Reconstruct<PreAggregationTestOutput> for [&CappedAttributionOutputs; 3] {
-        fn reconstruct(&self) -> PreAggregationTestOutput {
-            let [s0, s1, s2] = self;
 
+    impl Reconstruct<PreAggregationTestOutputInDecimal> for [&CappedAttributionOutputs; 3] {
+        fn reconstruct(&self) -> PreAggregationTestOutputInDecimal {
+            let [s0, s1, s2] = self;
             let attributed_breakdown_key_bits: BitDecomposed<Gf2> = BitDecomposed::new(
                 s0.attributed_breakdown_key_bits
                     .iter()
@@ -872,7 +899,6 @@ pub mod tests {
                     .zip(s2.attributed_breakdown_key_bits.iter())
                     .map(|((a, b), c)| [a, b, c].reconstruct()),
             );
-
             let capped_attributed_trigger_value_bits: BitDecomposed<Gf2> = BitDecomposed::new(
                 s0.capped_attributed_trigger_value
                     .iter()
@@ -881,50 +907,58 @@ pub mod tests {
                     .map(|((a, b), c)| [a, b, c].reconstruct()),
             );
 
-            PreAggregationTestOutput {
-                attributed_breakdown_key: attributed_breakdown_key_bits,
-                capped_attributed_trigger_value: capped_attributed_trigger_value_bits,
+            PreAggregationTestOutputInDecimal {
+                attributed_breakdown_key: attributed_breakdown_key_bits
+                    .iter()
+                    .map(Field::as_u128)
+                    .enumerate()
+                    .fold(0_u128, |acc, (i, x)| acc + (x << i)),
+                capped_attributed_trigger_value: capped_attributed_trigger_value_bits
+                    .iter()
+                    .map(Field::as_u128)
+                    .enumerate()
+                    .fold(0_u128, |acc, (i, x)| acc + (x << i)),
             }
         }
     }
 
     #[test]
-    fn semi_honest() {
+    fn semi_honest_attribution_and_capping() {
         run(|| async move {
             let world = TestWorld::default();
 
             let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit>> = vec![
                 /* First User */
-                test_input(123, false, 17, 0),
-                test_input(123, true, 0, 7),
-                test_input(123, false, 20, 0),
-                test_input(123, true, 0, 3),
+                oprf_test_input(123, false, 17, 0),
+                oprf_test_input(123, true, 0, 7),
+                oprf_test_input(123, false, 20, 0),
+                oprf_test_input(123, true, 0, 3),
                 /* Second User */
-                test_input(234, false, 12, 0),
-                test_input(234, true, 0, 5),
+                oprf_test_input(234, false, 12, 0),
+                oprf_test_input(234, true, 0, 5),
                 /* Third User */
-                test_input(345, false, 20, 0),
-                test_input(345, true, 0, 7),
-                test_input(345, false, 18, 0),
-                test_input(345, false, 12, 0),
-                test_input(345, true, 0, 7),
-                test_input(345, true, 0, 7),
-                test_input(345, true, 0, 7),
-                test_input(345, true, 0, 7),
+                oprf_test_input(345, false, 20, 0),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, false, 18, 0),
+                oprf_test_input(345, false, 12, 0),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, true, 0, 7),
             ];
 
-            let expected: [PreAggregationTestOutput; 11] = [
-                test_output::<Gf5Bit, Gf3Bit>(17, 7),
-                test_output::<Gf5Bit, Gf3Bit>(20, 0),
-                test_output::<Gf5Bit, Gf3Bit>(20, 3),
-                test_output::<Gf5Bit, Gf3Bit>(12, 5),
-                test_output::<Gf5Bit, Gf3Bit>(20, 7),
-                test_output::<Gf5Bit, Gf3Bit>(18, 0),
-                test_output::<Gf5Bit, Gf3Bit>(12, 0),
-                test_output::<Gf5Bit, Gf3Bit>(12, 7),
-                test_output::<Gf5Bit, Gf3Bit>(12, 7),
-                test_output::<Gf5Bit, Gf3Bit>(12, 7),
-                test_output::<Gf5Bit, Gf3Bit>(12, 4),
+            let expected: [PreAggregationTestOutputInDecimal; 11] = [
+                decimal_bd_key_and_value(17, 7),
+                decimal_bd_key_and_value(20, 0),
+                decimal_bd_key_and_value(20, 3),
+                decimal_bd_key_and_value(12, 5),
+                decimal_bd_key_and_value(20, 7),
+                decimal_bd_key_and_value(18, 0),
+                decimal_bd_key_and_value(12, 0),
+                decimal_bd_key_and_value(12, 7),
+                decimal_bd_key_and_value(12, 7),
+                decimal_bd_key_and_value(12, 7),
+                decimal_bd_key_and_value(12, 4),
             ];
             let num_saturating_bits: usize = 5;
 
@@ -951,22 +985,22 @@ pub mod tests {
 
             let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit>> = vec![
                 /* First User */
-                test_input(123, false, 17, 0),
-                test_input(123, true, 0, 7),
-                test_input(123, false, 20, 0),
-                test_input(123, true, 0, 3),
+                oprf_test_input(123, false, 17, 0),
+                oprf_test_input(123, true, 0, 7),
+                oprf_test_input(123, false, 20, 0),
+                oprf_test_input(123, true, 0, 3),
                 /* Second User */
-                test_input(234, false, 12, 0),
-                test_input(234, true, 0, 5),
+                oprf_test_input(234, false, 12, 0),
+                oprf_test_input(234, true, 0, 5),
                 /* Third User */
-                test_input(345, false, 20, 0),
-                test_input(345, true, 0, 7),
-                test_input(345, false, 18, 0),
-                test_input(345, false, 12, 0),
-                test_input(345, true, 0, 7),
-                test_input(345, true, 0, 7),
-                test_input(345, true, 0, 7),
-                test_input(345, true, 0, 7),
+                oprf_test_input(345, false, 20, 0),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, false, 18, 0),
+                oprf_test_input(345, false, 12, 0),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, true, 0, 7),
+                oprf_test_input(345, true, 0, 7),
             ];
 
             let mut expected = [0_u128; 32];
@@ -1000,18 +1034,18 @@ pub mod tests {
         run(|| async move {
             let world = TestWorld::default();
 
-            let records: Vec<PreAggregationTestOutput> = vec![
-                test_output::<Gf5Bit, Gf3Bit>(17, 7),
-                test_output::<Gf5Bit, Gf3Bit>(20, 0),
-                test_output::<Gf5Bit, Gf3Bit>(20, 3),
-                test_output::<Gf5Bit, Gf3Bit>(12, 5),
-                test_output::<Gf5Bit, Gf3Bit>(20, 7),
-                test_output::<Gf5Bit, Gf3Bit>(18, 0),
-                test_output::<Gf5Bit, Gf3Bit>(12, 0),
-                test_output::<Gf5Bit, Gf3Bit>(12, 7),
-                test_output::<Gf5Bit, Gf3Bit>(12, 7),
-                test_output::<Gf5Bit, Gf3Bit>(12, 7),
-                test_output::<Gf5Bit, Gf3Bit>(12, 4),
+            let records: Vec<PreAggregationTestInputInBits> = vec![
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(17, 7),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(20, 0),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(20, 3),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 5),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(20, 7),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(18, 0),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 0),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 7),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 7),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 7),
+                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 4),
             ];
 
             let mut expected = [0_u128; 32];
@@ -1034,16 +1068,16 @@ pub mod tests {
     }
 
     #[test]
-    fn semi_honest_move_value_to_single_bucket() {
+    fn semi_honest_move_value_to_single_bucket_in_range() {
         const MAX_BREAKDOWN_COUNT: usize = 127;
         for _ in 1..10 {
             run(|| async move {
                 let world = TestWorld::default();
                 let mut rng: rand::rngs::ThreadRng = thread_rng();
                 let count = rng.gen_range(1..MAX_BREAKDOWN_COUNT);
-                let breakdown_key = rng.gen_range(0..count);
+                let breakdown_key = rng.gen_range(1..count);
 
-                let value = Fp32BitPrime::truncate_from(10_u128);
+                let value: Fp32BitPrime = Fp32BitPrime::truncate_from(10_u128);
                 let mut expected = vec![Fp32BitPrime::truncate_from(0_u128); count];
                 expected[breakdown_key] = value;
 
@@ -1062,6 +1096,7 @@ pub mod tests {
                                 breakdown_key_share,
                                 value_share,
                                 count,
+                                false,
                             )
                             .await
                             .unwrap()
@@ -1073,4 +1108,51 @@ pub mod tests {
             });
         }
     }
+
+    #[test]
+    fn semi_honest_move_value_to_single_bucket_out_of_range() {
+        const MAX_BREAKDOWN_COUNT: usize = 127;
+        for robust_for_breakdown_key_gt_count in [true, false] {
+            for _ in 1..10 {
+                run(move || async move {
+                    let world = TestWorld::default();
+                    let mut rng: rand::rngs::ThreadRng = thread_rng();
+                    let count = rng.gen_range(1..MAX_BREAKDOWN_COUNT);
+                    let breakdown_key = rng.gen_range(count..MAX_BREAKDOWN_COUNT);
+
+                    let value: Fp32BitPrime = Fp32BitPrime::truncate_from(10_u128);
+                    let expected = vec![Fp32BitPrime::truncate_from(0_u128); count];
+
+                    let breakdown_key_bits =
+                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf8Bit::BITS);
+
+                    let result: Vec<_> = world
+                        .semi_honest(
+                            (breakdown_key_bits, value),
+                            |ctx, (breakdown_key_share, value_share)| async move {
+                                let validator = ctx.validator();
+                                let ctx = validator.context();
+                                move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
+                                    ctx.set_total_records(1),
+                                    RecordId::from(0),
+                                    breakdown_key_share,
+                                    value_share,
+                                    count,
+                                    robust_for_breakdown_key_gt_count,
+                                )
+                                .await
+                                .unwrap()
+                            },
+                        )
+                        .await
+                        .reconstruct();
+                    if robust_for_breakdown_key_gt_count {
+                        assert_eq!(result, expected);
+                    } else {
+                        assert_ne!(result, expected);
+                    }
+                });
+            }
+        }
+    }
 }

From b6ef12aaa3506d351cb8105c0000b0fbb54fb3a6 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <akoshelev@users.noreply.github.com>
Date: Wed, 11 Oct 2023 21:39:16 -0700
Subject: [PATCH 043/105] Fix some (all?) concurrency issues inside
 infrastructure (#792)

* Add tests that fail or hang if there is a send/receive bug in channel creation

* Add a failing test to `OrderingSender` suite to demonstrate concurrency bug

* Fix the concurrency bug inside OrderingSender

* Fix the concurrency bug inside UnorderedReceiver

* Address feedback

* Formatting
---
 src/helpers/buffers/ordering_sender.rs | 135 +++++++++++++++++++------
 src/helpers/gateway/mod.rs             | 113 ++++++++++++++++++++-
 src/helpers/gateway/receive.rs         |  18 ++--
 src/helpers/gateway/send.rs            |  70 +++++++------
 4 files changed, 258 insertions(+), 78 deletions(-)

diff --git a/src/helpers/buffers/ordering_sender.rs b/src/helpers/buffers/ordering_sender.rs
index d74a3f11b..ea1459d62 100644
--- a/src/helpers/buffers/ordering_sender.rs
+++ b/src/helpers/buffers/ordering_sender.rs
@@ -1,13 +1,11 @@
-#![allow(dead_code)] // TODO remove
-
 use std::{
     borrow::Borrow,
     cmp::Ordering,
     collections::VecDeque,
+    fmt::Debug,
     mem::drop,
     num::NonZeroUsize,
     pin::Pin,
-    sync::Arc,
     task::{Context, Poll},
 };
 
@@ -116,6 +114,7 @@ impl State {
 }
 
 /// An saved waker for a given index.
+#[derive(Debug)]
 struct WakerItem {
     /// The index.
     i: usize,
@@ -124,37 +123,59 @@ struct WakerItem {
 }
 
 /// A collection of saved wakers.
-#[derive(Default)]
+#[derive(Default, Debug)]
 struct WaitingShard {
+    /// The maximum index that was used to wake a task that belongs to this shard.
+    /// Updates to this shard will be rejected if the supplied index is less than this value.
+    /// See [`Add`] for more details.
+    ///
+    /// [`Add`]: WaitingShard::add
+    woken_at: usize,
     /// The saved wakers.  These are sorted on insert (see `add`) and
     /// presumably removed constantly, so a circular buffer is used.
     wakers: VecDeque<WakerItem>,
 }
 
 impl WaitingShard {
-    fn add(&mut self, i: usize, w: Waker) {
+    /// Add a waker that will be used to wake up a write to `i`.
+    ///
+    /// ## Errors
+    /// If `current` is behind the current position recorded in this shard.
+    fn add(&mut self, current: usize, i: usize, w: &Waker) -> Result<(), ()> {
+        if current < self.woken_at {
+            // this means this thread is out of sync and there was an update to channel's current
+            // position. Accepting a waker could mean it will never be awakened. Rejecting this operation
+            // will let the current thread to read the position again.
+            Err(())?;
+        }
+
         // Each new addition will tend to have a larger index, so search backwards and
         // replace an equal index or insert after a smaller index.
         // TODO: consider a binary search if the item cannot be added to the end.
-        let item = WakerItem { i, w };
+        let item = WakerItem { i, w: w.clone() };
         for j in (0..self.wakers.len()).rev() {
             match self.wakers[j].i.cmp(&i) {
                 Ordering::Greater => (),
                 Ordering::Equal => {
                     assert!(item.w.will_wake(&self.wakers[j].w));
                     self.wakers[j] = item;
-                    return;
+                    return Ok(());
                 }
                 Ordering::Less => {
                     self.wakers.insert(j + 1, item);
-                    return;
+                    return Ok(());
                 }
             }
         }
         self.wakers.insert(0, item);
+        Ok(())
     }
 
     fn wake(&mut self, i: usize) {
+        // Waking thread may have lost the race and got the lock after the successful write
+        // to the next element. Moving `woken_at` back will introduce a concurrency bug.
+        self.woken_at = std::cmp::max(self.woken_at, i);
+
         if let Some(idx) = self
             .wakers
             .iter()
@@ -192,8 +213,12 @@ impl Waiting {
         self.shards[idx].lock().unwrap()
     }
 
-    fn add(&self, i: usize, w: Waker) {
-        self.shard(i).add(i, w);
+    /// Add a waker that will be used to wake up a write to `i`.
+    ///
+    /// ## Errors
+    /// If `current` is behind the current position recorded in this shard.
+    fn add(&self, current: usize, i: usize, w: &Waker) -> Result<(), ()> {
+        self.shard(i).add(current, i, w)
     }
 
     fn wake(&self, i: usize) {
@@ -276,26 +301,43 @@ impl OrderingSender {
     {
         // This load here is on the hot path.
         // Don't acquire the state mutex unless this test passes.
-        match self.next.load(Acquire).cmp(&i) {
-            Ordering::Greater => {
-                panic!("attempt to write/close at index {i} twice");
-            }
-            Ordering::Equal => {
-                // OK, now it is our turn, so we need to hold a lock.
-                // No one else should be incrementing this atomic, so
-                // there should be no contention on this lock except for
-                // any calls to `take()`, which is tolerable.
-                let res = f(&mut self.state.lock().unwrap());
-                if res.is_ready() {
-                    let curr = self.next.fetch_add(1, AcqRel);
-                    debug_assert_eq!(i, curr, "we just checked this");
+        loop {
+            let curr = self.next.load(Acquire);
+            match curr.cmp(&i) {
+                Ordering::Greater => {
+                    panic!("attempt to write/close at index {i} twice");
+                }
+                Ordering::Equal => {
+                    // OK, now it is our turn, so we need to hold a lock.
+                    // No one else should be incrementing this atomic, so
+                    // there should be no contention on this lock except for
+                    // any calls to `take()`, which is tolerable.
+                    let res = f(&mut self.state.lock().unwrap());
+                    if res.is_ready() {
+                        let curr = self.next.fetch_add(1, AcqRel);
+                        debug_assert_eq!(i, curr, "we just checked this");
+                    }
+                    break res;
+                }
+                Ordering::Less => {
+                    // This is the hot path. Wait our turn. If our view of the world is obsolete
+                    // we won't be able to add a waker and need to read the atomic again.
+                    //
+                    // Here is why it works:
+                    // * The only thread updating the atomic is the one that is writing to `i`.
+                    // * If the write to `i` is successful, it wakes up the thread waiting to write `i` + 1.
+                    // * Adding a waker and waking it is within a critical section.
+                    //
+                    // There are two possible scenarios for two threads competing for `i` + 1 waker.
+                    // * Waiting thread adds a waker before writer thread attempts to wake it. This is a normal case
+                    // scenario and things work as expected
+                    // * Waiting thread attempts to add a waker after writer tried to wake it. This attempt will
+                    // be rejected because writer has moved the waiting shard position ahead and it won't match
+                    // the value of `self.next` read by the waiting thread.
+                    if self.waiting.add(curr, i, cx.waker()).is_ok() {
+                        break Poll::Pending;
+                    }
                 }
-                res
-            }
-            Ordering::Less => {
-                // This is the hot path. Wait our turn.
-                self.waiting.add(i, cx.waker().clone());
-                Poll::Pending
             }
         }
     }
@@ -322,11 +364,15 @@ impl OrderingSender {
     /// The stream interface requires a mutable reference to the stream itself.
     /// That's not possible here as we create a ton of immutable references to this.
     /// This wrapper takes a trivial reference so that we can implement `Stream`.
-    pub(crate) fn as_stream(&self) -> OrderedStream<&Self> {
+    #[cfg(all(test, any(unit_test, feature = "shuttle")))]
+    fn as_stream(&self) -> OrderedStream<&Self> {
         OrderedStream { sender: self }
     }
 
-    pub(crate) fn as_rc_stream(self: Arc<Self>) -> OrderedStream<Arc<Self>> {
+    #[cfg(all(test, unit_test))]
+    pub(crate) fn as_rc_stream(
+        self: crate::sync::Arc<Self>,
+    ) -> OrderedStream<crate::sync::Arc<Self>> {
         OrderedStream { sender: self }
     }
 }
@@ -403,8 +449,11 @@ mod test {
         stream::StreamExt,
         FutureExt,
     };
+    use futures_util::future::try_join_all;
     use generic_array::GenericArray;
     use rand::Rng;
+    #[cfg(feature = "shuttle")]
+    use shuttle::future as tokio;
     use typenum::Unsigned;
 
     use super::OrderingSender;
@@ -581,4 +630,28 @@ mod test {
             }
         });
     }
+
+    /// This test is supposed to eventually hang if there is a concurrency bug inside `OrderingSender`.
+    #[test]
+    fn parallel_send() {
+        const PARALLELISM: usize = 100;
+
+        run(|| async {
+            let sender = Arc::new(OrderingSender::new(
+                NonZeroUsize::new(PARALLELISM * <Fp31 as Serializable>::Size::USIZE).unwrap(),
+                NonZeroUsize::new(5).unwrap(),
+            ));
+
+            try_join_all((0..PARALLELISM).map(|i| {
+                tokio::spawn({
+                    let sender = Arc::clone(&sender);
+                    async move {
+                        sender.send(i, Fp31::truncate_from(i as u128)).await;
+                    }
+                })
+            }))
+            .await
+            .unwrap();
+        });
+    }
 }
diff --git a/src/helpers/gateway/mod.rs b/src/helpers/gateway/mod.rs
index ead1f32dc..c2a37916c 100644
--- a/src/helpers/gateway/mod.rs
+++ b/src/helpers/gateway/mod.rs
@@ -149,12 +149,13 @@ impl GatewayConfig {
 
 #[cfg(all(test, unit_test))]
 mod tests {
-    use futures_util::future::{join, try_join};
+    use std::iter::{repeat, zip};
+
+    use futures_util::future::{join, try_join, try_join_all};
 
-    use super::*;
     use crate::{
         ff::{Field, Fp31, Fp32BitPrime, Gf2},
-        helpers::{Direction, GatewayConfig, SendingEnd},
+        helpers::{Direction, GatewayConfig, Role, SendingEnd},
         protocol::{context::Context, RecordId},
         test_fixture::{Runner, TestWorld, TestWorldConfig},
     };
@@ -237,4 +238,110 @@ mod tests {
         spawned.await.unwrap();
         let _world = unsafe { Box::from_raw(world_ptr) };
     }
+
+    /// this test requires quite a few threads to simulate send contention and will panic if
+    /// there is more than one sender channel created per step.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 20)]
+    pub async fn send_contention() {
+        let (world, world_ptr) = make_world();
+
+        try_join_all(world.contexts().map(|ctx| {
+            tokio::spawn(async move {
+                const TOTAL_RECORDS: usize = 10;
+                let ctx = ctx
+                    .narrow("send_contention")
+                    .set_total_records(TOTAL_RECORDS);
+
+                let receive_handle = tokio::spawn({
+                    let ctx = ctx.clone();
+                    async move {
+                        for record in 0..TOTAL_RECORDS {
+                            let v = Fp31::truncate_from(u128::try_from(record).unwrap());
+                            let r = ctx
+                                .recv_channel::<Fp31>(ctx.role().peer(Direction::Left))
+                                .receive(record.into())
+                                .await
+                                .unwrap();
+
+                            assert_eq!(v, r, "Bad value for record {record}");
+                        }
+                    }
+                });
+
+                try_join_all(zip(0..TOTAL_RECORDS, repeat(ctx)).map(|(record, ctx)| {
+                    tokio::spawn(async move {
+                        let r = Fp31::truncate_from(u128::try_from(record).unwrap());
+                        ctx.send_channel(ctx.role().peer(Direction::Right))
+                            .send(RecordId::from(record), r)
+                            .await
+                            .unwrap();
+                    })
+                }))
+                .await
+                .unwrap();
+
+                receive_handle.await.unwrap();
+            })
+        }))
+        .await
+        .unwrap();
+
+        let _world = unsafe { Box::from_raw(world_ptr) };
+    }
+
+    /// This test should hang if receiver channel is not created atomically. It may occasionally
+    /// pass, but it will not give false negatives.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 20)]
+    pub async fn receive_contention() {
+        let (world, world_ptr) = make_world();
+        let contexts = world.contexts();
+
+        try_join_all(contexts.map(|ctx| {
+            tokio::spawn(async move {
+                const TOTAL_RECORDS: u32 = 20;
+                let ctx = ctx
+                    .narrow("receive_contention")
+                    .set_total_records(usize::try_from(TOTAL_RECORDS).unwrap());
+
+                tokio::spawn({
+                    let ctx = ctx.clone();
+                    async move {
+                        for record in 0..TOTAL_RECORDS {
+                            ctx.send_channel(ctx.role().peer(Direction::Right))
+                                .send(RecordId::from(record), Fp31::truncate_from(record))
+                                .await
+                                .unwrap();
+                        }
+                    }
+                });
+
+                try_join_all((0..TOTAL_RECORDS).zip(repeat(ctx)).map(|(record, ctx)| {
+                    tokio::spawn(async move {
+                        let r = ctx
+                            .recv_channel::<Fp31>(ctx.role().peer(Direction::Left))
+                            .receive(RecordId::from(record))
+                            .await
+                            .unwrap();
+                        assert_eq!(
+                            Fp31::truncate_from(record),
+                            r,
+                            "received bad value for record {record}"
+                        );
+                    })
+                }))
+                .await
+                .unwrap();
+            })
+        }))
+        .await
+        .unwrap();
+
+        let _world = unsafe { Box::from_raw(world_ptr) };
+    }
+
+    fn make_world() -> (&'static TestWorld, *mut TestWorld) {
+        let world = Box::leak(Box::<TestWorld>::default());
+        let world_ptr = world as *mut _;
+        (world, world_ptr)
+    }
 }
diff --git a/src/helpers/gateway/receive.rs b/src/helpers/gateway/receive.rs
index 4f50e7b48..282ff68e2 100644
--- a/src/helpers/gateway/receive.rs
+++ b/src/helpers/gateway/receive.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use dashmap::DashMap;
+use dashmap::{mapref::entry::Entry, DashMap};
 use futures::Stream;
 
 use crate::{
@@ -65,13 +65,15 @@ impl<T: Transport> Default for GatewayReceivers<T> {
 
 impl<T: Transport> GatewayReceivers<T> {
     pub fn get_or_create<F: FnOnce() -> UR<T>>(&self, channel_id: &ChannelId, ctr: F) -> UR<T> {
-        let receivers = &self.inner;
-        if let Some(recv) = receivers.get(channel_id) {
-            recv.clone()
-        } else {
-            let stream = ctr();
-            receivers.insert(channel_id.clone(), stream.clone());
-            stream
+        // TODO: raw entry API if it becomes available to avoid cloning the key
+        match self.inner.entry(channel_id.clone()) {
+            Entry::Occupied(entry) => entry.get().clone(),
+            Entry::Vacant(entry) => {
+                let stream = ctr();
+                entry.insert(stream.clone());
+
+                stream
+            }
         }
     }
 }
diff --git a/src/helpers/gateway/send.rs b/src/helpers/gateway/send.rs
index c36875829..4eb876af0 100644
--- a/src/helpers/gateway/send.rs
+++ b/src/helpers/gateway/send.rs
@@ -5,7 +5,7 @@ use std::{
     task::{Context, Poll},
 };
 
-use dashmap::DashMap;
+use dashmap::{mapref::entry::Entry, DashMap};
 use futures::Stream;
 use typenum::Unsigned;
 
@@ -127,42 +127,40 @@ impl GatewaySenders {
             total_records.is_specified(),
             "unspecified total records for {channel_id:?}"
         );
-        let senders = &self.inner;
-        if let Some(sender) = senders.get(channel_id) {
-            (Arc::clone(&sender), None)
-        } else {
-            const SPARE: Option<NonZeroUsize> = NonZeroUsize::new(64);
-            // a little trick - if number of records is indeterminate, set the capacity to 1.
-            // Any send will wake the stream reader then, effectively disabling buffering.
-            // This mode is clearly inefficient, so avoid using this mode.
-            let write_size = if total_records.is_indeterminate() {
-                NonZeroUsize::new(1).unwrap()
-            } else {
-                // capacity is defined in terms of number of elements, while sender wants bytes
-                // so perform the conversion here
-                capacity
-                    .checked_mul(
-                        NonZeroUsize::new(M::Size::USIZE)
-                            .expect("Message size should be greater than 0"),
-                    )
-                    .expect("capacity should not overflow")
-            };
-
-            let sender = Arc::new(GatewaySender::new(
-                channel_id.clone(),
-                OrderingSender::new(write_size, SPARE.unwrap()),
-                total_records,
-            ));
-            if senders
-                .insert(channel_id.clone(), Arc::clone(&sender))
-                .is_some()
-            {
-                panic!("TODO - make sender creation contention less dangerous");
+
+        // TODO: raw entry API would be nice to have here but it's not exposed yet
+        match self.inner.entry(channel_id.clone()) {
+            Entry::Occupied(entry) => (Arc::clone(entry.get()), None),
+            Entry::Vacant(entry) => {
+                const SPARE: Option<NonZeroUsize> = NonZeroUsize::new(64);
+                // a little trick - if number of records is indeterminate, set the capacity to 1.
+                // Any send will wake the stream reader then, effectively disabling buffering.
+                // This mode is clearly inefficient, so avoid using this mode.
+                let write_size = if total_records.is_indeterminate() {
+                    NonZeroUsize::new(1).unwrap()
+                } else {
+                    // capacity is defined in terms of number of elements, while sender wants bytes
+                    // so perform the conversion here
+                    capacity
+                        .checked_mul(
+                            NonZeroUsize::new(M::Size::USIZE)
+                                .expect("Message size should be greater than 0"),
+                        )
+                        .expect("capacity should not overflow")
+                };
+
+                let sender = Arc::new(GatewaySender::new(
+                    channel_id.clone(),
+                    OrderingSender::new(write_size, SPARE.unwrap()),
+                    total_records,
+                ));
+                entry.insert(Arc::clone(&sender));
+
+                (
+                    Arc::clone(&sender),
+                    Some(GatewaySendStream { inner: sender }),
+                )
             }
-            let stream = GatewaySendStream {
-                inner: Arc::clone(&sender),
-            };
-            (sender, Some(stream))
         }
     }
 }

From 64f6fc2f7d890a4a13e88b6b6a2d1716f83af4ee Mon Sep 17 00:00:00 2001
From: Artem Ignatyev <cryo28@gmail.com>
Date: Fri, 13 Oct 2023 13:35:37 -0500
Subject: [PATCH 044/105] Simplify FromRequest::from_request for
 QueryConfigParams (#802)

It seems that the code introduces a few unnecessary local structs to
parse http query parameters into. But these structs are the same as the final
QueryType-nested structs.

So, we can parse the params into those structs directly and make the
code simpler

Co-authored-by: Artem Ignatyev <aignatyev@meta.com>
---
 src/helpers/transport/query.rs |  1 +
 src/net/http_serde.rs          | 88 +++++++---------------------------
 2 files changed, 17 insertions(+), 72 deletions(-)

diff --git a/src/helpers/transport/query.rs b/src/helpers/transport/query.rs
index 8f77a3f9f..ab4e0761b 100644
--- a/src/helpers/transport/query.rs
+++ b/src/helpers/transport/query.rs
@@ -250,6 +250,7 @@ pub struct IpaQueryConfig {
     /// input report format in which all fields are secret-shared. This option is provided
     /// only for development and testing purposes and may be removed in the future.
     #[cfg_attr(feature = "clap", arg(long))]
+    #[serde(default)]
     pub plaintext_match_keys: bool,
 }
 
diff --git a/src/net/http_serde.rs b/src/net/http_serde.rs
index 25432654a..faa2ec13d 100644
--- a/src/net/http_serde.rs
+++ b/src/net/http_serde.rs
@@ -80,20 +80,14 @@ pub mod echo {
 }
 
 pub mod query {
-    use std::{
-        fmt::{Display, Formatter},
-        num::NonZeroU32,
-    };
+    use std::fmt::{Display, Formatter};
 
     use async_trait::async_trait;
     use axum::extract::{FromRequest, Query, RequestParts};
 
     use crate::{
         ff::FieldType,
-        helpers::query::{
-            ContributionBits, IpaQueryConfig, QueryConfig, QuerySize, QueryType,
-            SparseAggregateQueryConfig,
-        },
+        helpers::query::{QueryConfig, QuerySize, QueryType},
         net::Error,
     };
 
@@ -129,71 +123,21 @@ pub mod query {
             let query_type = match query_type.as_str() {
                 #[cfg(any(test, feature = "cli", feature = "test-fixture"))]
                 QueryType::TEST_MULTIPLY_STR => Ok(QueryType::TestMultiply),
-                QueryType::SEMIHONEST_IPA_STR | QueryType::MALICIOUS_IPA_STR => {
-                    #[derive(serde::Deserialize)]
-                    struct IPAQueryConfigParam {
-                        per_user_credit_cap: u32,
-                        max_breakdown_key: u32,
-                        attribution_window_seconds: Option<NonZeroU32>,
-                        num_multi_bits: u32,
-                        #[serde(default)]
-                        plaintext_match_keys: bool,
-                    }
-                    let Query(IPAQueryConfigParam {
-                        per_user_credit_cap,
-                        max_breakdown_key,
-                        attribution_window_seconds,
-                        num_multi_bits,
-                        plaintext_match_keys,
-                    }) = req.extract().await?;
-
-                    match query_type.as_str() {
-                        QueryType::SEMIHONEST_IPA_STR => {
-                            Ok(QueryType::SemiHonestIpa(IpaQueryConfig {
-                                per_user_credit_cap,
-                                max_breakdown_key,
-                                attribution_window_seconds,
-                                num_multi_bits,
-                                plaintext_match_keys,
-                            }))
-                        }
-                        QueryType::MALICIOUS_IPA_STR => {
-                            Ok(QueryType::MaliciousIpa(IpaQueryConfig {
-                                per_user_credit_cap,
-                                max_breakdown_key,
-                                attribution_window_seconds,
-                                num_multi_bits,
-                                plaintext_match_keys,
-                            }))
-                        }
-                        &_ => unreachable!(),
-                    }
+                QueryType::SEMIHONEST_IPA_STR => {
+                    let Query(q) = req.extract().await?;
+                    Ok(QueryType::SemiHonestIpa(q))
                 }
-                QueryType::SEMIHONEST_AGGREGATE_STR | QueryType::MALICIOUS_AGGREGATE_STR => {
-                    #[derive(serde::Deserialize)]
-                    struct AggregateQueryConfigParam {
-                        contribution_bits: ContributionBits,
-                        num_contributions: u32,
-                    }
-                    let Query(AggregateQueryConfigParam {
-                        contribution_bits,
-                        num_contributions,
-                    }) = req.extract().await?;
-                    match query_type.as_str() {
-                        QueryType::SEMIHONEST_AGGREGATE_STR => Ok(
-                            QueryType::SemiHonestSparseAggregate(SparseAggregateQueryConfig {
-                                contribution_bits,
-                                num_contributions,
-                            }),
-                        ),
-                        QueryType::MALICIOUS_AGGREGATE_STR => Ok(
-                            QueryType::MaliciousSparseAggregate(SparseAggregateQueryConfig {
-                                contribution_bits,
-                                num_contributions,
-                            }),
-                        ),
-                        &_ => unreachable!(),
-                    }
+                QueryType::MALICIOUS_IPA_STR => {
+                    let Query(q) = req.extract().await?;
+                    Ok(QueryType::MaliciousIpa(q))
+                }
+                QueryType::SEMIHONEST_AGGREGATE_STR => {
+                    let Query(q) = req.extract().await?;
+                    Ok(QueryType::SemiHonestSparseAggregate(q))
+                }
+                QueryType::MALICIOUS_AGGREGATE_STR => {
+                    let Query(q) = req.extract().await?;
+                    Ok(QueryType::MaliciousSparseAggregate(q))
                 }
                 other => Err(Error::bad_query_value("query_type", other)),
             }?;

From 16378e1e2c4fab70c2d8ca1bca7c926729e552f3 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Wed, 11 Oct 2023 21:12:15 -0700
Subject: [PATCH 045/105] Add sanitizer step

---
 .github/workflows/check.yml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 5b63b1354..d13a5d2c1 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -140,4 +140,19 @@ jobs:
 
       - name: Web Tests
         run: cargo test --no-default-features --features "aggregate-circuit cli web-app real-world-infra test-fixture descriptive-gate"
+  sanitize:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        sanitizer: [ address, leak, memory, thread ]
+    steps:
+      - uses: actions/checkout@v3
+        # https://github.com/rust-lang/rust/issues/39699
+      - uses: dtolnay/rust-toolchain@nightly
+      - name: Add rust source
+        run: rustup component add rust-src
+      - name: Run tests with sanitizer
+        run: RUSTFLAGS="-Z sanitizer=${{ matrix.sanitizer }} -Z sanitizer-memory-track-origins" cargo test --target x86_64-unknown-linux-gnu
 

From 872e32f6c2482c6710dfdfa4bb3a1ad298bdb157 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Wed, 11 Oct 2023 21:22:24 -0700
Subject: [PATCH 046/105] Manually schedule check workflow

---
 .github/workflows/check.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index d13a5d2c1..4f41a64dc 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -14,6 +14,7 @@ on:
       - "src/**/*"
       - "benches/**/*"
       - "tests/**/*"
+  workflow_dispatch:
 
 env:
   CARGO_TERM_COLOR: always

From 8755577c32c024ba28fc0825742e9eec54fb710b Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 12 Oct 2023 13:16:26 -0700
Subject: [PATCH 047/105] Fix memory leak in `TempDir`

---
 tests/common/mod.rs      |  5 ++---
 tests/common/tempdir.rs  | 12 ++++++------
 tests/helper_networks.rs |  2 +-
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index 7990bccb6..774890b2f 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -188,8 +188,7 @@ pub fn test_multiply(config_dir: &Path, https: bool) {
 }
 
 pub fn test_network(https: bool) {
-    // set to true to always keep the temp dir after test finishes
-    let dir = TempDir::new(false);
+    let dir = TempDir::new_delete_on_drop();
     let path = dir.path();
 
     println!("generating configuration in {}", path.display());
@@ -206,7 +205,7 @@ pub fn test_ipa(mode: IpaSecurityModel, https: bool) {
 pub fn test_ipa_with_config(mode: IpaSecurityModel, https: bool, config: IpaQueryConfig) {
     const INPUT_SIZE: usize = 10;
     // set to true to always keep the temp dir after test finishes
-    let dir = TempDir::new(false);
+    let dir = TempDir::new_delete_on_drop();
     let path = dir.path();
 
     println!("generating configuration in {}", path.display());
diff --git a/tests/common/tempdir.rs b/tests/common/tempdir.rs
index f1fd69465..3c056ab44 100644
--- a/tests/common/tempdir.rs
+++ b/tests/common/tempdir.rs
@@ -1,4 +1,4 @@
-use std::{mem, path::Path, thread};
+use std::{path::Path, thread};
 
 use tempfile::tempdir;
 
@@ -12,16 +12,16 @@ pub struct TempDir {
 }
 
 impl TempDir {
-    /// Creates a new temporary directory. If `delete` is set to `false`, then it won't be cleaned up
-    /// after drop.
+    /// Creates a new temporary directory that will be deleted when this instance is dropped.
+    /// There is an exception if thread is panicking, then it won't be.
     ///
     /// ## Panics
     /// Panics if a new temp dir cannot be created.
     #[must_use]
-    pub fn new(delete: bool) -> Self {
+    pub fn new_delete_on_drop() -> Self {
         Self {
             inner: Some(tempdir().expect("Can create temp directory")),
-            delete,
+            delete: true,
         }
     }
 
@@ -37,7 +37,7 @@ impl Drop for TempDir {
     fn drop(&mut self) {
         if !self.delete || thread::panicking() {
             let td = self.inner.take().unwrap();
-            mem::forget(td);
+            let _ = td.into_path();
         }
     }
 }
diff --git a/tests/helper_networks.rs b/tests/helper_networks.rs
index d00340f75..28ffb6f35 100644
--- a/tests/helper_networks.rs
+++ b/tests/helper_networks.rs
@@ -39,7 +39,7 @@ fn https_semi_honest_ipa() {
 #[test]
 #[cfg(all(test, web_test))]
 fn keygen_confgen() {
-    let dir = TempDir::new(false);
+    let dir = TempDir::new_delete_on_drop();
     let path = dir.path();
 
     let sockets: [_; 3] = array::from_fn(|_| TcpListener::bind("127.0.0.1:0").unwrap());

From d8e195de8b9da91dda1305330e9daafd3e33372d Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 12 Oct 2023 17:12:11 -0700
Subject: [PATCH 048/105] Keep ASAN and Leak sanitizer only

Others don't work
---
 .github/workflows/check.yml | 60 ++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 4f41a64dc..a7eda1177 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -70,13 +70,11 @@ jobs:
       - name: Run compact gate tests
         run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture compact-gate"
 
-  extra:
-    name: Additional Builds and Concurrency Tests
-    env:
-      RUSTFLAGS: -D warnings -C target-cpu=native
-
+  release:
+    name: Release builds and tests
     runs-on: ubuntu-latest
-
+    env:
+      RUSTFLAGS: -C target-cpu=native
     steps:
       - uses: actions/checkout@v3
 
@@ -97,34 +95,22 @@ jobs:
       - name: Release Build
         run: cargo build --release
 
-      - name: Build benchmarks
-        run: cargo build --benches --no-default-features --features "enable-benches descriptive-gate"
-
       - name: Build concurrency tests
         run: cargo build --release --features shuttle
 
-      - name: Build concurrency tests (debug mode)
-        run: cargo build --features shuttle
-
       - name: Run concurrency tests
         run: cargo test --release --features shuttle
 
-      - name: Run IPA bench
-        run: cargo bench --bench oneshot_ipa --no-default-features --features "enable-benches descriptive-gate"
-
-      - name: Run arithmetic bench
-        run: cargo bench --bench oneshot_arithmetic --no-default-features --features "enable-benches descriptive-gate"
-
-      - name: Run compact gate tests
-        run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture compact-gate"
-
-  aggregate:
-    name: Build and test aggregate circuit
+  extra:
+    name: Additional Builds and Concurrency Tests
+    env:
+      RUSTFLAGS: -D warnings -C target-cpu=native
 
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v3
+
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy,rustfmt
@@ -139,21 +125,35 @@ jobs:
             target/
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.toml') }}
 
-      - name: Web Tests
-        run: cargo test --no-default-features --features "aggregate-circuit cli web-app real-world-infra test-fixture descriptive-gate"
+      - name: Build benchmarks
+        run: cargo build --benches --no-default-features --features "enable-benches descriptive-gate"
+
+      - name: Build concurrency tests (debug mode)
+        run: cargo build --features shuttle
+
+      - name: Run IPA bench
+        run: cargo bench --bench oneshot_ipa --no-default-features --features "enable-benches descriptive-gate"
+
+      - name: Run arithmetic bench
+        run: cargo bench --bench oneshot_arithmetic --no-default-features --features "enable-benches descriptive-gate"
+
+      - name: Run compact gate tests
+        run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture compact-gate"
+
+  # sanitizers currently require nightly https://github.com/rust-lang/rust/issues/39699
   sanitize:
     runs-on: ubuntu-latest
-    timeout-minutes: 10
     strategy:
       fail-fast: false
       matrix:
-        sanitizer: [ address, leak, memory, thread ]
+        sanitizer: [ address, leak ]
+    env:
+      TARGET: x86_64-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v3
-        # https://github.com/rust-lang/rust/issues/39699
       - uses: dtolnay/rust-toolchain@nightly
-      - name: Add rust source
+      - name: Add Rust sources
         run: rustup component add rust-src
       - name: Run tests with sanitizer
-        run: RUSTFLAGS="-Z sanitizer=${{ matrix.sanitizer }} -Z sanitizer-memory-track-origins" cargo test --target x86_64-unknown-linux-gnu
+        run: RUSTFLAGS="-Z sanitizer=${{ matrix.sanitizer }} -Z sanitizer-memory-track-origins" cargo test -Z build-std --target $TARGET --no-default-features --features "cli web-app real-world-infra test-fixture descriptive-gate"
 

From 36b9c7dbe00907d40a27a2a219c923a3b038a1dd Mon Sep 17 00:00:00 2001
From: Martin Thomson <mt@lowentropy.net>
Date: Mon, 16 Oct 2023 13:45:04 +1100
Subject: [PATCH 049/105] Restructure the bucketing code

Move the function to a file on its own.
Skip iterations when the number of buckets is less than half the number
of bits and `robust` is false.
Refactor tests.
Add an overflow test and guard against having more than 128 buckets
(which we can't support).
Fix gen_range() invocations.

Closes #803.
---
 Cargo.toml                                    |   2 +-
 src/ff/prime_field.rs                         |  12 +
 src/protocol/prf_sharding/bucket.rs           | 234 ++++++++++++++++++
 .../prf_sharding/feature_label_dot_product.rs |  10 +-
 src/protocol/prf_sharding/mod.rs              | 181 +-------------
 5 files changed, 261 insertions(+), 178 deletions(-)
 create mode 100644 src/protocol/prf_sharding/bucket.rs

diff --git a/Cargo.toml b/Cargo.toml
index e264d503f..2ba6d8b67 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -106,7 +106,7 @@ cfg_aliases = "0.1.1"
 command-fds = "0.2.2"
 hex = "0.4"
 permutation = "0.4.1"
-proptest = "1.0.0"
+proptest = "1.3"
 tempfile = "3"
 tokio-rustls = { version = "0.24.0", features = ["dangerous_configuration"] }
 
diff --git a/src/ff/prime_field.rs b/src/ff/prime_field.rs
index 49962a83d..56391a8a0 100644
--- a/src/ff/prime_field.rs
+++ b/src/ff/prime_field.rs
@@ -132,6 +132,18 @@ macro_rules! field_impl {
             }
         }
 
+        impl std::iter::Sum for $field {
+            fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+                iter.fold(Self::ZERO, |a, b| a + b)
+            }
+        }
+
+        impl<'a> std::iter::Sum<&'a $field> for $field {
+            fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
+                iter.fold(Self::ZERO, |a, b| a + *b)
+            }
+        }
+
         impl TryFrom<u128> for $field {
             type Error = crate::error::Error;
 
diff --git a/src/protocol/prf_sharding/bucket.rs b/src/protocol/prf_sharding/bucket.rs
new file mode 100644
index 000000000..6349f91a6
--- /dev/null
+++ b/src/protocol/prf_sharding/bucket.rs
@@ -0,0 +1,234 @@
+use embed_doc_image::embed_doc_image;
+
+use crate::{
+    error::Error,
+    ff::{GaloisField, PrimeField, Serializable},
+    protocol::{
+        basics::SecureMul, context::UpgradedContext, prf_sharding::BinaryTreeDepthStep,
+        step::BitOpStep, RecordId,
+    },
+    secret_sharing::{
+        replicated::malicious::ExtendableField, BitDecomposed, Linear as LinearSecretSharing,
+    },
+};
+
+#[embed_doc_image("tree-aggregation", "images/tree_aggregation.png")]
+/// This function moves a single value to a correct bucket using tree aggregation approach
+///
+/// Here is how it works
+/// The combined value,  [`value`] forms the root of a binary tree as follows:
+/// ![Tree propagation][tree-aggregation]
+///
+/// This value is propagated through the tree, with each subsequent iteration doubling the number of multiplications.
+/// In the first round,  r=BK-1, multiply the most significant bit ,[`bd_key`]_r by the value to get [`bd_key`]_r.[`value`]. From that,
+/// produce [`row_contribution`]_r,0 =[`value`]-[`bd_key`]_r.[`value`] and [`row_contribution`]_r,1=[`bd_key`]_r.[`value`].
+/// This takes the most significant bit of `bd_key` and places value in one of the two child nodes of the binary tree.
+/// At each successive round, the next most significant bit is propagated from the leaf nodes of the tree into further leaf nodes:
+/// [`row_contribution`]_r+1,q,0 =[`row_contribution`]_r,q - [`bd_key`]_r+1.[`row_contribution`]_r,q and [`row_contribution`]_r+1,q,1 =[`bd_key`]_r+1.[`row_contribution`]_r,q.  
+/// The work of each iteration therefore doubles relative to the one preceding.
+///
+/// In case a malicious entity sends a out of range breakdown key (i.e. greater than the max count) to this function, we need to do some
+/// extra processing to ensure contribution doesn't end up in a wrong bucket. However, this requires extra multiplications.
+/// This would potentially not be needed in IPA (as the breakdown key is provided by the report collector, so a bad value only spoils their own result) but useful for PAM.
+/// This can be by passing `robust` as true.
+pub async fn move_single_value_to_bucket<BK, C, S, F>(
+    ctx: C,
+    record_id: RecordId,
+    bd_key: BitDecomposed<S>,
+    value: S,
+    breakdown_count: usize,
+    robust: bool,
+) -> Result<Vec<S>, Error>
+where
+    BK: GaloisField,
+    C: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
+    F: PrimeField + ExtendableField,
+{
+    let mut step: usize = 1 << BK::BITS;
+
+    assert!(
+        breakdown_count <= 1 << BK::BITS,
+        "Asking for more buckets ({breakdown_count}) than bits in the key ({}) allow",
+        BK::BITS
+    );
+    assert!(
+        breakdown_count <= 128,
+        "Our step implementation (BitOpStep) cannot go past 64"
+    );
+    let mut row_contribution = vec![value; breakdown_count];
+
+    for (tree_depth, bit_of_bdkey) in bd_key.iter().enumerate().rev() {
+        let span = step >> 1;
+        if !robust && span > breakdown_count {
+            step = span;
+            continue;
+        }
+
+        let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
+        let mut futures = Vec::with_capacity(breakdown_count / step);
+
+        for (i, tree_index) in (0..breakdown_count).step_by(step).enumerate() {
+            let bit_c = depth_c.narrow(&BitOpStep::from(i));
+
+            if robust || tree_index + span < breakdown_count {
+                futures.push(row_contribution[tree_index].multiply(bit_of_bdkey, bit_c, record_id));
+            }
+        }
+        let contributions = ctx.parallel_join(futures).await?;
+
+        for (index, bdbit_contribution) in contributions.into_iter().enumerate() {
+            let left_index = index * step;
+            let right_index = left_index + span;
+
+            row_contribution[left_index] -= &bdbit_contribution;
+            if right_index < breakdown_count {
+                row_contribution[right_index] = bdbit_contribution;
+            }
+        }
+        step = span;
+    }
+    Ok(row_contribution)
+}
+
+#[cfg(all(test, unit_test))]
+pub mod tests {
+    use rand::thread_rng;
+
+    use crate::{
+        ff::{Field, Fp32BitPrime, Gf5Bit, Gf8Bit},
+        protocol::{
+            context::{Context, UpgradableContext, Validator},
+            prf_sharding::bucket::move_single_value_to_bucket,
+            RecordId,
+        },
+        rand::Rng,
+        secret_sharing::SharedValue,
+        test_executor::run,
+        test_fixture::{get_bits, Reconstruct, Runner, TestWorld},
+    };
+
+    const MAX_BREAKDOWN_COUNT: usize = 1 << Gf5Bit::BITS;
+    const VALUE: u32 = 10;
+
+    async fn move_to_bucket(count: usize, breakdown_key: usize, robust: bool) -> Vec<Fp32BitPrime> {
+        let breakdown_key_bits =
+            get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf5Bit::BITS);
+        let value = Fp32BitPrime::truncate_from(VALUE);
+
+        TestWorld::default()
+            .semi_honest(
+                (breakdown_key_bits, value),
+                |ctx, (breakdown_key_share, value_share)| async move {
+                    let validator = ctx.validator();
+                    let ctx = validator.context();
+                    move_single_value_to_bucket::<Gf5Bit, _, _, Fp32BitPrime>(
+                        ctx.set_total_records(1),
+                        RecordId::from(0),
+                        breakdown_key_share,
+                        value_share,
+                        count,
+                        robust,
+                    )
+                    .await
+                    .unwrap()
+                },
+            )
+            .await
+            .reconstruct()
+    }
+
+    #[test]
+    fn semi_honest_move_in_range() {
+        run(|| async move {
+            let mut rng = thread_rng();
+            let count = rng.gen_range(1..MAX_BREAKDOWN_COUNT);
+            let breakdown_key = rng.gen_range(0..count);
+            let mut expected = vec![Fp32BitPrime::ZERO; count];
+            expected[breakdown_key] = Fp32BitPrime::truncate_from(VALUE);
+
+            let result = move_to_bucket(count, breakdown_key, false).await;
+            assert_eq!(result, expected, "expected value at index {breakdown_key}");
+        });
+    }
+
+    #[test]
+    fn semi_honest_move_in_range_robust() {
+        run(|| async move {
+            let mut rng = thread_rng();
+            let count = rng.gen_range(1..MAX_BREAKDOWN_COUNT);
+            let breakdown_key = rng.gen_range(0..count);
+            let mut expected = vec![Fp32BitPrime::ZERO; count];
+            expected[breakdown_key] = Fp32BitPrime::truncate_from(VALUE);
+
+            let result = move_to_bucket(count, breakdown_key, true).await;
+            assert_eq!(result, expected, "expected value at index {breakdown_key}");
+        });
+    }
+
+    #[test]
+    fn semi_honest_move_out_of_range() {
+        run(move || async move {
+            let mut rng: rand::rngs::ThreadRng = thread_rng();
+            let count = rng.gen_range(2..MAX_BREAKDOWN_COUNT - 1);
+            let breakdown_key = rng.gen_range(count..MAX_BREAKDOWN_COUNT);
+
+            let result = move_to_bucket(count, breakdown_key, false).await;
+            assert_eq!(result.len(), count);
+            assert_eq!(
+                result.into_iter().sum::<Fp32BitPrime>(),
+                Fp32BitPrime::truncate_from(VALUE)
+            );
+        });
+    }
+
+    #[test]
+    fn semi_honest_move_out_of_range_robust() {
+        run(move || async move {
+            let mut rng: rand::rngs::ThreadRng = thread_rng();
+            let count = rng.gen_range(2..MAX_BREAKDOWN_COUNT - 1);
+            let breakdown_key = rng.gen_range(count..MAX_BREAKDOWN_COUNT);
+
+            let result = move_to_bucket(count, breakdown_key, true).await;
+            assert_eq!(result.len(), count);
+            assert!(result.into_iter().all(|x| x == Fp32BitPrime::ZERO));
+        });
+    }
+
+    #[test]
+    #[should_panic]
+    fn move_out_of_range_too_many_buckets_type() {
+        run(move || async move {
+            _ = move_to_bucket(MAX_BREAKDOWN_COUNT + 1, 0, false).await;
+        });
+    }
+
+    #[test]
+    #[should_panic]
+    fn move_out_of_range_too_many_buckets_steps() {
+        run(move || async move {
+            let breakdown_key_bits = get_bits::<Fp32BitPrime>(0, Gf8Bit::BITS);
+            let value = Fp32BitPrime::truncate_from(VALUE);
+
+            _ = TestWorld::default()
+                .semi_honest(
+                    (breakdown_key_bits, value),
+                    |ctx, (breakdown_key_share, value_share)| async move {
+                        let validator = ctx.validator();
+                        let ctx = validator.context();
+                        move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
+                            ctx.set_total_records(1),
+                            RecordId::from(0),
+                            breakdown_key_share,
+                            value_share,
+                            129,
+                            false,
+                        )
+                        .await
+                        .unwrap()
+                    },
+                )
+                .await;
+        });
+    }
+}
diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index 0dfc28f3a..9ef0b0ad6 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -261,10 +261,10 @@ where
         let num_user_rows = rows_for_user.len();
         let contexts = ctx_for_row_number[..num_user_rows - 1].to_owned();
         let record_ids = record_id_for_row_depth[..num_user_rows].to_owned();
+        record_id_for_row_depth[..num_user_rows]
+            .iter_mut()
+            .for_each(|count| *count += 1);
 
-        for count in &mut record_id_for_row_depth[..num_user_rows] {
-            *count += 1;
-        }
         #[allow(clippy::async_yields_async)]
         // this is ok, because seq join wants a stream of futures
         async move {
@@ -273,7 +273,7 @@ where
     }));
 
     // Execute all of the async futures (sequentially), and flatten the result
-    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
+    let flattened_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
         .flat_map(|x| stream_iter(x.unwrap()));
 
     // modulus convert feature vector bits from shares in `Z_2` to shares in `Z_p`
@@ -281,7 +281,7 @@ where
         prime_field_ctx
             .narrow(&Step::ModulusConvertFeatureVectorBits)
             .set_total_records(num_outputs),
-        flattenned_stream,
+        flattened_stream,
         0..FV::BITS,
     );
 
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 8b35b371f..cd589bc02 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1,21 +1,18 @@
 use std::iter::{repeat, zip};
 
-use embed_doc_image::embed_doc_image;
 use futures::{stream::iter as stream_iter, TryStreamExt};
 use futures_util::{future::try_join, StreamExt};
 use ipa_macros::Step;
 
-use super::{
-    basics::if_else, boolean::saturating_sum::SaturatingSum, modulus_conversion::convert_bits,
-    step::BitOpStep,
-};
 use crate::{
     error::Error,
     ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
     protocol::{
-        basics::{SecureMul, ShareKnownValue},
-        boolean::or::or,
+        basics::{if_else, SecureMul, ShareKnownValue},
+        boolean::{or::or, saturating_sum::SaturatingSum},
         context::{UpgradableContext, UpgradedContext, Validator},
+        modulus_conversion::convert_bits,
+        step::BitOpStep,
         RecordId,
     },
     secret_sharing::{
@@ -28,6 +25,7 @@ use crate::{
     seq_join::{seq_join, seq_try_join_all},
 };
 
+pub mod bucket;
 #[cfg(feature = "descriptive-gate")]
 pub mod feature_label_dot_product;
 
@@ -635,7 +633,7 @@ where
             let record_id: RecordId = RecordId::from(i);
             let bd_key = bk_bits.unwrap();
             async move {
-                move_single_value_to_bucket::<BK, _, _, _>(
+                bucket::move_single_value_to_bucket::<BK, _, _, _>(
                     ctx,
                     record_id,
                     bd_key,
@@ -662,86 +660,14 @@ where
         .await
 }
 
-#[embed_doc_image("tree-aggregation", "images/tree_aggregation.png")]
-/// This function moves a single value to a correct bucket using tree aggregation approach
-///
-/// Here is how it works
-/// The combined value,  [`value`] forms the root of a binary tree as follows:
-/// ![Tree propagation][tree-aggregation]
-///
-/// This value is propagated through the tree, with each subsequent iteration doubling the number of multiplications.
-/// In the first round,  r=BK-1, multiply the most significant bit ,[`bd_key`]_r by the value to get [`bd_key`]_r.[`value`]. From that,
-/// produce [`row_contribution`]_r,0 =[`value`]-[`bd_key`]_r.[`value`] and [`row_contribution`]_r,1=[`bd_key`]_r.[`value`].
-/// This takes the most significant bit of `bd_key` and places value in one of the two child nodes of the binary tree.
-/// At each successive round, the next most significant bit is propagated from the leaf nodes of the tree into further leaf nodes:
-/// [`row_contribution`]_r+1,q,0 =[`row_contribution`]_r,q - [`bd_key`]_r+1.[`row_contribution`]_r,q and [`row_contribution`]_r+1,q,1 =[`bd_key`]_r+1.[`row_contribution`]_r,q.  
-/// The work of each iteration therefore doubles relative to the one preceding.
-///
-/// In case a malicious entity sends a out of range breakdown key (i.e. greater than the max count) to this function, we need to do some
-/// extra processing to ensure contribution doesn't end up in a wrong bucket. However, this requires extra multiplications.
-/// This would potentially not be needed in IPA (as aggregation is done after pre-processing which should be able to throw such input) but useful for PAM.
-/// This can be by passing `robust_for_breakdown_key_gt_count as true
-async fn move_single_value_to_bucket<BK, C, S, F>(
-    ctx: C,
-    record_id: RecordId,
-    bd_key: BitDecomposed<S>,
-    value: S,
-    breakdown_count: usize,
-    robust_for_breakdown_key_gt_count: bool,
-) -> Result<Vec<S>, Error>
-where
-    BK: GaloisField,
-    C: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
-    F: PrimeField + ExtendableField,
-{
-    let mut step: usize = 1 << BK::BITS;
-
-    assert!(breakdown_count <= 1 << BK::BITS);
-    let mut row_contribution = vec![value; breakdown_count];
-
-    for (tree_depth, bit_of_bdkey) in bd_key.iter().rev().enumerate() {
-        let depth_c = ctx.narrow(&BinaryTreeDepthStep::from(tree_depth));
-        let span = step >> 1;
-        let mut futures = Vec::with_capacity(breakdown_count / step);
-
-        for (i, tree_index) in (0..breakdown_count).step_by(step).enumerate() {
-            let bit_c = depth_c.narrow(&BitOpStep::from(i));
-
-            if robust_for_breakdown_key_gt_count || tree_index + span < breakdown_count {
-                futures.push(row_contribution[tree_index].multiply(bit_of_bdkey, bit_c, record_id));
-            }
-        }
-        let contributions = ctx.parallel_join(futures).await?;
-
-        for (index, bdbit_contribution) in contributions.into_iter().enumerate() {
-            let left_index = index * step;
-            let right_index = left_index + span;
-
-            row_contribution[left_index] -= &bdbit_contribution;
-            if right_index < breakdown_count {
-                row_contribution[right_index] = bdbit_contribution;
-            }
-        }
-        step = span;
-    }
-    Ok(row_contribution)
-}
-
 #[cfg(all(test, unit_test))]
 pub mod tests {
-    use rand::thread_rng;
-
     use super::{attribution_and_capping, CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
-        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf3Bit, Gf5Bit, Gf8Bit},
+        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf3Bit, Gf5Bit},
         protocol::{
-            context::{Context, UpgradableContext, Validator},
-            prf_sharding::{
-                attribution_and_capping_and_aggregation, do_aggregation,
-                move_single_value_to_bucket,
-            },
-            RecordId,
+            context::{UpgradableContext, Validator},
+            prf_sharding::{attribution_and_capping_and_aggregation, do_aggregation},
         },
         rand::Rng,
         secret_sharing::{
@@ -1070,93 +996,4 @@ pub mod tests {
             assert_eq!(result, &expected);
         });
     }
-
-    #[test]
-    fn semi_honest_move_value_to_single_bucket_in_range() {
-        const MAX_BREAKDOWN_COUNT: usize = 127;
-        for _ in 1..10 {
-            run(|| async move {
-                let world = TestWorld::default();
-                let mut rng: rand::rngs::ThreadRng = thread_rng();
-                let count = rng.gen_range(1..MAX_BREAKDOWN_COUNT);
-                let breakdown_key = rng.gen_range(1..count);
-
-                let value: Fp32BitPrime = Fp32BitPrime::truncate_from(10_u128);
-                let mut expected = vec![Fp32BitPrime::truncate_from(0_u128); count];
-                expected[breakdown_key] = value;
-
-                let breakdown_key_bits =
-                    get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf8Bit::BITS);
-
-                let result: Vec<_> = world
-                    .semi_honest(
-                        (breakdown_key_bits, value),
-                        |ctx, (breakdown_key_share, value_share)| async move {
-                            let validator = ctx.validator();
-                            let ctx = validator.context();
-                            move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
-                                ctx.set_total_records(1),
-                                RecordId::from(0),
-                                breakdown_key_share,
-                                value_share,
-                                count,
-                                false,
-                            )
-                            .await
-                            .unwrap()
-                        },
-                    )
-                    .await
-                    .reconstruct();
-                assert_eq!(result, expected);
-            });
-        }
-    }
-
-    #[test]
-    fn semi_honest_move_value_to_single_bucket_out_of_range() {
-        const MAX_BREAKDOWN_COUNT: usize = 127;
-        for robust_for_breakdown_key_gt_count in [true, false] {
-            for _ in 1..10 {
-                run(move || async move {
-                    let world = TestWorld::default();
-                    let mut rng: rand::rngs::ThreadRng = thread_rng();
-                    let count = rng.gen_range(1..MAX_BREAKDOWN_COUNT);
-                    let breakdown_key = rng.gen_range(count..MAX_BREAKDOWN_COUNT);
-
-                    let value: Fp32BitPrime = Fp32BitPrime::truncate_from(10_u128);
-                    let expected = vec![Fp32BitPrime::truncate_from(0_u128); count];
-
-                    let breakdown_key_bits =
-                        get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf8Bit::BITS);
-
-                    let result: Vec<_> = world
-                        .semi_honest(
-                            (breakdown_key_bits, value),
-                            |ctx, (breakdown_key_share, value_share)| async move {
-                                let validator = ctx.validator();
-                                let ctx = validator.context();
-                                move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
-                                    ctx.set_total_records(1),
-                                    RecordId::from(0),
-                                    breakdown_key_share,
-                                    value_share,
-                                    count,
-                                    robust_for_breakdown_key_gt_count,
-                                )
-                                .await
-                                .unwrap()
-                            },
-                        )
-                        .await
-                        .reconstruct();
-                    if robust_for_breakdown_key_gt_count {
-                        assert_eq!(result, expected);
-                    } else {
-                        assert_ne!(result, expected);
-                    }
-                });
-            }
-        }
-    }
 }

From 05626b1975743c2fab15d700d26365788d82cc5c Mon Sep 17 00:00:00 2001
From: Martin Thomson <mt@lowentropy.net>
Date: Mon, 16 Oct 2023 14:17:01 +1100
Subject: [PATCH 050/105] Remove proptest bump

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 2ba6d8b67..34b4f01d9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -106,7 +106,7 @@ cfg_aliases = "0.1.1"
 command-fds = "0.2.2"
 hex = "0.4"
 permutation = "0.4.1"
-proptest = "1.3"
+proptest = "1"
 tempfile = "3"
 tokio-rustls = { version = "0.24.0", features = ["dangerous_configuration"] }
 

From 2bbfeec09a9faec07dbe9afdbc9f9dd873495d5a Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Tue, 17 Oct 2023 05:24:26 +0800
Subject: [PATCH 051/105] #[dynamic] attribute takes an integer literal to
 specify the max number of steps (#799)

* #[dynamic] attribute takes an integer literal to specify the maximum number of steps we generate

* change the for_each() to for loop
---
 ipa-macros/src/derive_step/mod.rs             | 53 ++++++++++++++++---
 src/protocol/attribution/mod.rs               |  2 +-
 src/protocol/context/upgrade.rs               |  2 +-
 .../modulus_conversion/convert_shares.rs      |  2 +-
 .../prf_sharding/feature_label_dot_product.rs |  2 +-
 src/protocol/prf_sharding/mod.rs              |  4 +-
 src/protocol/sort/apply_sort/shuffle.rs       |  2 +-
 src/protocol/sort/mod.rs                      |  2 +-
 src/protocol/step/mod.rs                      |  4 +-
 9 files changed, 57 insertions(+), 16 deletions(-)

diff --git a/ipa-macros/src/derive_step/mod.rs b/ipa-macros/src/derive_step/mod.rs
index 702c050b2..f2ffc006e 100644
--- a/ipa-macros/src/derive_step/mod.rs
+++ b/ipa-macros/src/derive_step/mod.rs
@@ -47,6 +47,8 @@ use crate::{
     tree::Node,
 };
 
+const MAX_DYNAMIC_STEPS: usize = 1024;
+
 trait CaseStyle {
     fn to_snake_case(&self) -> String;
 }
@@ -113,19 +115,24 @@ fn impl_as_ref(ident: &syn::Ident, data: &syn::DataEnum) -> Result<TokenStream2,
     let mut const_arrays = Vec::new();
     let mut arms = Vec::new();
 
-    data.variants.iter().for_each(|v| {
+    for v in data.variants.iter() {
         let ident = &v.ident;
         let ident_snake_case = ident.to_string().to_snake_case();
         let ident_upper_case = ident_snake_case.to_uppercase();
 
         if is_dynamic_step(v) {
-            // create an array of 64 strings and use the variant index as array index
-            let steps = (0..64)
+            let num_steps = match get_dynamic_step_count(v) {
+                Ok(n) => n,
+                Err(e) => return Err(e),
+            };
+
+            // create an array of `num_steps` strings and use the variant index as array index
+            let steps = (0..num_steps)
                 .map(|i| format!("{}{}", ident_snake_case, i))
                 .collect::<Vec<_>>();
             let steps_array_ident = format_ident!("{}_DYNAMIC_STEP", ident_upper_case);
             const_arrays.extend(quote!(
-                const #steps_array_ident: [&str; 64] = [#(#steps),*];
+                const #steps_array_ident: [&str; #num_steps] = [#(#steps),*];
             ));
             arms.extend(quote!(
                 Self::#ident(i) => #steps_array_ident[usize::try_from(*i).unwrap()],
@@ -136,7 +143,7 @@ fn impl_as_ref(ident: &syn::Ident, data: &syn::DataEnum) -> Result<TokenStream2,
                 Self::#ident => #ident_snake_case,
             ));
         }
-    });
+    }
 
     Ok(quote!(
         impl AsRef<str> for #ident {
@@ -212,7 +219,10 @@ fn get_meta_data_for(
         .iter()
         .flat_map(|v| {
             if is_dynamic_step(v) {
-                (0..64)
+                // using `unwrap()` here since we have already validated the
+                // format in `impl_as_ref()`.
+                let num_steps = get_dynamic_step_count(v).unwrap();
+                (0..num_steps)
                     .map(|i| format!("{}{}", v.ident.to_string().to_snake_case(), i))
                     .collect::<Vec<_>>()
             } else {
@@ -281,3 +291,34 @@ fn get_meta_data_for(
 fn is_dynamic_step(variant: &syn::Variant) -> bool {
     variant.attrs.iter().any(|x| x.path().is_ident("dynamic"))
 }
+
+/// Returns the number literal argument passed to #[dynamic(...)] attribute.
+///
+/// # Errors
+/// Returns an error if the argument format is invalid or the number of steps
+/// exceeds `MAX_DYNAMIC_STEPS`. The error can be used to generate a compile
+/// time error. The function assumes that `is_dynamic_step()` returns true for
+/// the given variant.
+fn get_dynamic_step_count(variant: &syn::Variant) -> Result<usize, syn::Error> {
+    let dynamic_attr = variant
+        .attrs
+        .iter()
+        .find(|x| x.path().is_ident("dynamic"))
+        .unwrap();
+    let arg = dynamic_attr
+        .parse_args::<syn::LitInt>()
+        .map(|x| x.base10_parse::<usize>().unwrap())
+        .ok();
+    match arg {
+        // guard against gigantic code generation
+        Some(n) if n <= MAX_DYNAMIC_STEPS => Ok(n),
+        _ => Err(syn::Error::new_spanned(
+            dynamic_attr,
+            format!(
+                "ipa_macros::step \"dynamic\" attribute expects a number of steps \
+                            (<= {}) in parentheses: #[dynamic(...)].",
+                MAX_DYNAMIC_STEPS,
+            ),
+        )),
+    }
+}
diff --git a/src/protocol/attribution/mod.rs b/src/protocol/attribution/mod.rs
index bad651407..d3a117da5 100644
--- a/src/protocol/attribution/mod.rs
+++ b/src/protocol/attribution/mod.rs
@@ -438,7 +438,7 @@ pub(in crate::protocol) enum Step {
 
 #[derive(Step)]
 pub(crate) enum InteractionPatternStep {
-    #[dynamic]
+    #[dynamic(64)]
     Depth(usize),
 }
 
diff --git a/src/protocol/context/upgrade.rs b/src/protocol/context/upgrade.rs
index c75bd6d75..cb5365d13 100644
--- a/src/protocol/context/upgrade.rs
+++ b/src/protocol/context/upgrade.rs
@@ -165,7 +165,7 @@ where
 
 #[derive(Step)]
 pub(crate) enum Upgrade2DVectors {
-    #[dynamic]
+    #[dynamic(64)]
     Upgrade2d(usize),
 }
 
diff --git a/src/protocol/modulus_conversion/convert_shares.rs b/src/protocol/modulus_conversion/convert_shares.rs
index 82ad12e7a..406c05fdc 100644
--- a/src/protocol/modulus_conversion/convert_shares.rs
+++ b/src/protocol/modulus_conversion/convert_shares.rs
@@ -51,7 +51,7 @@ use crate::{
 
 #[derive(Step)]
 pub(crate) enum ConvertSharesStep {
-    #[dynamic]
+    #[dynamic(64)]
     ConvertBit(u32),
     Upgrade,
     Xor1,
diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/prf_sharding/feature_label_dot_product.rs
index 0dfc28f3a..0043ddc16 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/prf_sharding/feature_label_dot_product.rs
@@ -117,7 +117,7 @@ impl InputsRequiredFromPrevRow {
 
 #[derive(Step)]
 pub enum UserNthRowStep {
-    #[dynamic]
+    #[dynamic(64)]
     Row(usize),
 }
 
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 8b35b371f..6562e3e5b 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -183,7 +183,7 @@ pub struct CappedAttributionOutputs {
 
 #[derive(Step)]
 pub enum UserNthRowStep {
-    #[dynamic]
+    #[dynamic(64)]
     Row(usize),
 }
 
@@ -195,7 +195,7 @@ impl From<usize> for UserNthRowStep {
 
 #[derive(Step)]
 pub enum BinaryTreeDepthStep {
-    #[dynamic]
+    #[dynamic(64)]
     Depth(usize),
 }
 
diff --git a/src/protocol/sort/apply_sort/shuffle.rs b/src/protocol/sort/apply_sort/shuffle.rs
index 6554db4f1..9268e40dd 100644
--- a/src/protocol/sort/apply_sort/shuffle.rs
+++ b/src/protocol/sort/apply_sort/shuffle.rs
@@ -18,7 +18,7 @@ use crate::{
 
 #[derive(Step)]
 pub(crate) enum InnerVectorElementStep {
-    #[dynamic]
+    #[dynamic(64)]
     Elem(usize),
 }
 
diff --git a/src/protocol/sort/mod.rs b/src/protocol/sort/mod.rs
index 7caaf1c91..8427f0b03 100644
--- a/src/protocol/sort/mod.rs
+++ b/src/protocol/sort/mod.rs
@@ -25,7 +25,7 @@ pub(crate) enum SortStep {
     Compose,
     ShuffleRevealPermutation,
     SortKeys,
-    #[dynamic]
+    #[dynamic(64)]
     MultiApplyInv(u32),
 }
 
diff --git a/src/protocol/step/mod.rs b/src/protocol/step/mod.rs
index 495a6e0e8..fc5fca1ba 100644
--- a/src/protocol/step/mod.rs
+++ b/src/protocol/step/mod.rs
@@ -53,7 +53,7 @@ impl Step for str {}
 /// updated with a new step scheme.
 #[derive(Step)]
 pub enum BitOpStep {
-    #[dynamic]
+    #[dynamic(64)]
     Bit(usize),
 }
 
@@ -79,6 +79,6 @@ impl From<usize> for BitOpStep {
 #[derive(Step)]
 pub(crate) enum IpaProtocolStep {
     /// Sort shares by the match key
-    #[dynamic]
+    #[dynamic(64)]
     Sort(usize),
 }

From fc6aba7441472f9f9fb0420e2b9083ffc9d2b363 Mon Sep 17 00:00:00 2001
From: Andy Leiserson <aleiserson@mozilla.com>
Date: Wed, 18 Oct 2023 16:36:56 -0700
Subject: [PATCH 052/105] Update aes crate and enable intrinsics on aarch64

(This used to require the nightly compiler, but no longer does.)
---
 .cargo/config.toml | 2 ++
 Cargo.toml         | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)
 create mode 100644 .cargo/config.toml

diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 000000000..cc463d79d
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,2 @@
+[target.aarch64-apple-darwin]
+rustflags = ["--cfg", "aes_armv8"]
diff --git a/Cargo.toml b/Cargo.toml
index 34b4f01d9..9e4314b41 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ aggregate-circuit = []
 
 [dependencies]
 ipa-macros = { version = "*", path = "./ipa-macros" }
-aes = "0.8"
+aes = "0.8.3"
 async-trait = "0.1.68"
 axum = { version = "0.5.17", optional = true, features = ["http2"] }
 axum-server = { version = "0.5.1", optional = true, features = ["rustls", "rustls-pemfile", "tls-rustls"] }

From ecd18856042ffeef6ac0e16a5b0c266e78c2ffbb Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Wed, 4 Oct 2023 10:02:53 +0800
Subject: [PATCH 053/105] Add attribution window to OPRF aggregation

---
 src/ff/galois_field.rs                 |  17 +-
 src/ff/mod.rs                          |   2 +-
 src/protocol/boolean/comparison.rs     |   6 +-
 src/protocol/boolean/saturating_sum.rs |   6 +-
 src/protocol/prf_sharding/mod.rs       | 350 ++++++++++++++++++++++---
 src/secret_sharing/decomposed.rs       |  97 ++++++-
 6 files changed, 427 insertions(+), 51 deletions(-)

diff --git a/src/ff/galois_field.rs b/src/ff/galois_field.rs
index 18b6b58c8..f8a99c3f5 100644
--- a/src/ff/galois_field.rs
+++ b/src/ff/galois_field.rs
@@ -5,7 +5,7 @@ use std::{
 
 use bitvec::prelude::{bitarr, BitArr, Lsb0};
 use generic_array::GenericArray;
-use typenum::{Unsigned, U1, U4, U5};
+use typenum::{Unsigned, U1, U3, U4, U5};
 
 use crate::{
     ff::{Field, Serializable},
@@ -25,6 +25,7 @@ pub trait GaloisField:
 
 // Bit store type definitions
 type U8_1 = BitArr!(for 8, in u8, Lsb0);
+type U8_3 = BitArr!(for 24, in u8, Lsb0);
 type U8_4 = BitArr!(for 32, in u8, Lsb0);
 type U8_5 = BitArr!(for 40, in u8, Lsb0);
 
@@ -32,6 +33,10 @@ impl Block for U8_1 {
     type Size = U1;
 }
 
+impl Block for U8_3 {
+    type Size = U3;
+}
+
 impl Block for U8_4 {
     type Size = U4;
 }
@@ -550,6 +555,16 @@ bit_array_impl!(
     0b1_0000_0000_0000_0000_0000_0000_1000_1101_u128
 );
 
+bit_array_impl!(
+    bit_array_20,
+    Gf20Bit,
+    U8_3,
+    20,
+    bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+    // x^20 + x^7 + x^3 + x^2 + 1
+    0b1000_0000_0000_1000_1101_u128
+);
+
 bit_array_impl!(
     bit_array_8,
     Gf8Bit,
diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 3a47dc5e0..1d5d3d9c4 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -9,7 +9,7 @@ mod prime_field;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 
 pub use field::{Field, FieldType};
-pub use galois_field::{GaloisField, Gf2, Gf32Bit, Gf3Bit, Gf40Bit, Gf5Bit, Gf8Bit};
+pub use galois_field::{GaloisField, Gf2, Gf20Bit, Gf32Bit, Gf3Bit, Gf40Bit, Gf5Bit, Gf8Bit};
 use generic_array::{ArrayLength, GenericArray};
 #[cfg(any(test, feature = "weak-field"))]
 pub use prime_field::Fp31;
diff --git a/src/protocol/boolean/comparison.rs b/src/protocol/boolean/comparison.rs
index 148117854..e7ddbfb7a 100644
--- a/src/protocol/boolean/comparison.rs
+++ b/src/protocol/boolean/comparison.rs
@@ -3,7 +3,7 @@ use ipa_macros::Step;
 use super::or::or;
 use crate::{
     error::Error,
-    ff::PrimeField,
+    ff::{Field, PrimeField},
     protocol::{
         boolean::random_bits_generator::RandomBitsGenerator,
         context::{Context, UpgradedContext},
@@ -205,7 +205,7 @@ pub async fn bitwise_less_than_constant<F, C, S>(
     c: u128,
 ) -> Result<S, Error>
 where
-    F: PrimeField,
+    F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
     for<'a> &'a S: LinearRefOps<'a, S, F>,
@@ -236,7 +236,7 @@ async fn first_differing_bit<F, C, S>(
     b: u128,
 ) -> Result<Vec<S>, Error>
 where
-    F: PrimeField,
+    F: Field,
     C: Context,
     S: LinearSecretSharing<F> + BasicProtocols<C, F>,
     for<'a> &'a S: LinearRefOps<'a, S, F>,
diff --git a/src/protocol/boolean/saturating_sum.rs b/src/protocol/boolean/saturating_sum.rs
index f57551d98..3ce2d9e4d 100644
--- a/src/protocol/boolean/saturating_sum.rs
+++ b/src/protocol/boolean/saturating_sum.rs
@@ -24,7 +24,7 @@ impl<S: LinearSecretSharing<Gf2>> SaturatingSum<S> {
     /// If one of the multiplications errors
     ///
     /// # Panics
-    /// If something try to add a bit decomposed value larger than this `SaturatingSum` can accomodate
+    /// If something try to add a bit decomposed value larger than this `SaturatingSum` can accommodate
     pub async fn add<C>(
         &self,
         ctx: C,
@@ -175,7 +175,9 @@ where
 ///
 /// If `compute_carry_out` is set to `true`, then the mutable refernce to `carry_in` is mutated to take on the value of the `carry_out` bit
 ///
-async fn one_bit_subtractor<C, SB>(
+/// # Errors
+/// If one of the multiplications errors
+pub async fn one_bit_subtractor<C, SB>(
     ctx: C,
     record_id: RecordId,
     x: &SB,
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 110dc452a..39ab0c1ac 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1,15 +1,19 @@
-use std::iter::{repeat, zip};
+use std::{
+    iter::{repeat, zip},
+    num::NonZeroU32,
+};
 
 use futures::{stream::iter as stream_iter, TryStreamExt};
 use futures_util::{future::try_join, StreamExt};
 use ipa_macros::Step;
 
+use super::boolean::saturating_sum::SaturatingSum;
 use crate::{
     error::Error,
     ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
     protocol::{
         basics::{if_else, SecureMul, ShareKnownValue},
-        boolean::{or::or, saturating_sum::SaturatingSum},
+        boolean::{comparison::bitwise_less_than_constant, or::or},
         context::{UpgradableContext, UpgradedContext, Validator},
         modulus_conversion::convert_bits,
         step::BitOpStep,
@@ -29,11 +33,32 @@ pub mod bucket;
 #[cfg(feature = "descriptive-gate")]
 pub mod feature_label_dot_product;
 
-pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {
+pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField, TS: GaloisField> {
     prf_of_match_key: u64,
     is_trigger_bit: Replicated<Gf2>,
     breakdown_key: Replicated<BK>,
     trigger_value: Replicated<TV>,
+    timestamp: Replicated<TS>,
+}
+
+impl<BK: GaloisField, TV: GaloisField, TS: GaloisField> PrfShardedIpaInputRow<BK, TV, TS> {
+    pub fn breakdown_key_bits(&self) -> BitDecomposed<Replicated<Gf2>> {
+        BitDecomposed::decompose(BK::BITS, |i| {
+            self.breakdown_key.map(|v| Gf2::truncate_from(v[i]))
+        })
+    }
+
+    pub fn trigger_value_bits(&self) -> BitDecomposed<Replicated<Gf2>> {
+        BitDecomposed::decompose(TV::BITS, |i| {
+            self.trigger_value.map(|v| Gf2::truncate_from(v[i]))
+        })
+    }
+
+    pub fn timestamp_bits(&self) -> BitDecomposed<Replicated<Gf2>> {
+        BitDecomposed::decompose(TS::BITS, |i| {
+            self.timestamp.map(|v| Gf2::truncate_from(v[i]))
+        })
+    }
 }
 
 struct InputsRequiredFromPrevRow {
@@ -41,6 +66,7 @@ struct InputsRequiredFromPrevRow {
     attributed_breakdown_key_bits: BitDecomposed<Replicated<Gf2>>,
     saturating_sum: SaturatingSum<Replicated<Gf2>>,
     difference_to_cap: BitDecomposed<Replicated<Gf2>>,
+    source_event_timestamp: BitDecomposed<Replicated<Gf2>>,
 }
 
 impl InputsRequiredFromPrevRow {
@@ -68,24 +94,27 @@ impl InputsRequiredFromPrevRow {
     ///         - `did_trigger_get_attributed` - a secret-shared bit indicating if this row corresponds to a trigger event
     ///           which was attributed. Might be able to reveal this (after a shuffle and the addition of dummies) to minimize
     ///           the amount of processing work that must be done in the Aggregation stage.
-    pub async fn compute_row_with_previous<C, BK, TV>(
+    #[allow(clippy::too_many_lines)]
+    pub async fn compute_row_with_previous<C, BK, TV, TS>(
         &mut self,
         ctx: C,
         record_id: RecordId,
-        input_row: &PrfShardedIpaInputRow<BK, TV>,
+        input_row: &PrfShardedIpaInputRow<BK, TV, TS>,
         num_saturating_sum_bits: usize,
+        attribution_window_seconds: Option<NonZeroU32>,
     ) -> Result<CappedAttributionOutputs, Error>
     where
         C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
         BK: GaloisField,
         TV: GaloisField,
+        TS: GaloisField,
     {
-        let bd_key = BitDecomposed::decompose(BK::BITS, |i| {
-            input_row.breakdown_key.map(|v| Gf2::truncate_from(v[i]))
-        });
-        let tv = BitDecomposed::decompose(TV::BITS, |i| {
-            input_row.trigger_value.map(|v| Gf2::truncate_from(v[i]))
-        });
+        let (bd_key, tv, timestamp) = (
+            input_row.breakdown_key_bits(),
+            input_row.trigger_value_bits(),
+            input_row.timestamp_bits(),
+        );
+
         assert_eq!(self.saturating_sum.sum.len(), num_saturating_sum_bits);
 
         let share_of_one = Replicated::share_known_value(&ctx, Gf2::ONE);
@@ -108,6 +137,20 @@ impl InputsRequiredFromPrevRow {
         )
         .await?;
 
+        let source_event_timestamp = match attribution_window_seconds {
+            None => self.source_event_timestamp.clone(),
+            Some(_) => {
+                timestamp_of_most_recent_source_event(
+                    ctx.narrow(&Step::SourceEventTimestamp),
+                    record_id,
+                    &input_row.is_trigger_bit,
+                    &self.source_event_timestamp,
+                    &timestamp,
+                )
+                .await?
+            }
+        };
+
         let did_trigger_get_attributed = input_row
             .is_trigger_bit
             .multiply(
@@ -117,7 +160,7 @@ impl InputsRequiredFromPrevRow {
             )
             .await?;
 
-        let attributed_trigger_value = zero_out_trigger_value_unless_attributed(
+        let mut attributed_trigger_value = zero_out_trigger_value_unless_attributed(
             ctx.narrow(&Step::AttributedTriggerValue),
             record_id,
             &did_trigger_get_attributed,
@@ -125,6 +168,16 @@ impl InputsRequiredFromPrevRow {
         )
         .await?;
 
+        attributed_trigger_value = zero_out_trigger_value_if_outside_attribution_window(
+            ctx.narrow(&Step::CheckAttributionWindow),
+            record_id,
+            &attributed_trigger_value,
+            attribution_window_seconds,
+            &timestamp,
+            &source_event_timestamp,
+        )
+        .await?;
+
         let updated_sum = self
             .saturating_sum
             .add(
@@ -162,6 +215,7 @@ impl InputsRequiredFromPrevRow {
         self.attributed_breakdown_key_bits = attributed_breakdown_key_bits.clone();
         self.saturating_sum = updated_sum;
         self.difference_to_cap = difference_to_cap;
+        self.source_event_timestamp = source_event_timestamp;
 
         let outputs_for_aggregation = CappedAttributionOutputs {
             did_trigger_get_attributed,
@@ -210,6 +264,10 @@ pub(crate) enum Step {
     DidTriggerGetAttributed,
     AttributedBreakdownKey,
     AttributedTriggerValue,
+    CheckAttributionWindow,
+    ComputeTimeDelta,
+    ConvertTimeDeltaBits,
+    SourceEventTimestamp,
     ComputeSaturatingSum,
     IsSaturatedAndPrevRowNotSaturated,
     ComputeDifferenceToCap,
@@ -251,14 +309,15 @@ where
     context_per_row_depth
 }
 
-fn chunk_rows_by_user<BK, TV>(
-    input_rows: Vec<PrfShardedIpaInputRow<BK, TV>>,
-) -> Vec<Vec<PrfShardedIpaInputRow<BK, TV>>>
+fn chunk_rows_by_user<BK, TV, TS>(
+    input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
+) -> Vec<Vec<PrfShardedIpaInputRow<BK, TV, TS>>>
 where
     BK: GaloisField,
     TV: GaloisField,
+    TS: GaloisField,
 {
-    let mut rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV>> = vec![];
+    let mut rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV, TS>> = vec![];
 
     let mut rows_chunked_by_user = vec![];
     for row in input_rows {
@@ -293,20 +352,23 @@ where
 /// Propagates errors from multiplications
 /// # Panics
 /// Propagates errors from multiplications
-pub async fn attribution_and_capping<C, BK, TV>(
+pub async fn attribution_and_capping<C, BK, TV, TS>(
     sh_ctx: C,
-    input_rows: Vec<PrfShardedIpaInputRow<BK, TV>>,
+    input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
     num_saturating_sum_bits: usize,
+    attribution_window_seconds: Option<NonZeroU32>,
 ) -> Result<Vec<CappedAttributionOutputs>, Error>
 where
     C: UpgradableContext,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
     BK: GaloisField,
     TV: GaloisField,
+    TS: GaloisField,
 {
     assert!(num_saturating_sum_bits > TV::BITS as usize);
     assert!(TV::BITS > 0);
     assert!(BK::BITS > 0);
+    assert!(TS::BITS > 0);
 
     let rows_chunked_by_user = chunk_rows_by_user(input_rows);
     let histogram = compute_histogram_of_users_with_row_count(&rows_chunked_by_user);
@@ -332,6 +394,7 @@ where
                 .collect(),
             rows_for_user,
             num_saturating_sum_bits,
+            attribution_window_seconds,
         ));
     }
     let outputs_chunked_by_user = seq_try_join_all(sh_ctx.active_work(), futures).await?;
@@ -341,16 +404,18 @@ where
         .collect::<Vec<CappedAttributionOutputs>>())
 }
 
-async fn evaluate_per_user_attribution_circuit<C, BK, TV>(
+async fn evaluate_per_user_attribution_circuit<C, BK, TV, TS>(
     ctx_for_row_number: &[C],
     record_id_for_each_depth: Vec<RecordId>,
-    rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV>>,
+    rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
     num_saturating_sum_bits: usize,
+    attribution_window_seconds: Option<NonZeroU32>,
 ) -> Result<Vec<CappedAttributionOutputs>, Error>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
     BK: GaloisField,
     TV: GaloisField,
+    TS: GaloisField,
 {
     assert!(!rows_for_user.is_empty());
     if rows_for_user.len() == 1 {
@@ -374,6 +439,7 @@ where
                 record_id_for_this_row_depth,
                 row,
                 num_saturating_sum_bits,
+                attribution_window_seconds,
             )
             .await?;
 
@@ -387,14 +453,15 @@ where
 /// Upon encountering the first row of data from a new user (as distinguished by a different OPRF of the match key)
 /// this function encapsulates the variables that must be initialized. No communication is required for this first row.
 ///
-fn initialize_new_device_attribution_variables<BK, TV>(
+fn initialize_new_device_attribution_variables<BK, TV, TS>(
     share_of_one: Replicated<Gf2>,
-    input_row: &PrfShardedIpaInputRow<BK, TV>,
+    input_row: &PrfShardedIpaInputRow<BK, TV, TS>,
     num_saturating_sum_bits: usize,
 ) -> InputsRequiredFromPrevRow
 where
     BK: GaloisField,
     TV: GaloisField,
+    TS: GaloisField,
 {
     InputsRequiredFromPrevRow {
         ever_encountered_a_source_event: share_of_one - &input_row.is_trigger_bit,
@@ -408,6 +475,7 @@ where
         // This is incorrect in the case that the CAP is less than the maximum value of "trigger value" for a single row
         // Not a problem if you assume that's an invalid input
         difference_to_cap: BitDecomposed::new(vec![Replicated::ZERO; TV::BITS as usize]),
+        source_event_timestamp: BitDecomposed::new(vec![Replicated::ZERO; TS::BITS as usize]),
     }
 }
 
@@ -415,10 +483,6 @@ where
 /// To support "Last Touch Attribution" we move the `breakdown_key` of the most recent source event
 /// down to all of trigger events that follow it.
 ///
-/// The logic here is extremely simple. For each row:
-/// (a) if it is a source event, take the breakdown key bits.
-/// (b) if it is a trigger event, take the breakdown key bits from the preceding line
-///
 async fn breakdown_key_of_most_recent_source_event<C>(
     ctx: C,
     record_id: RecordId,
@@ -426,14 +490,60 @@ async fn breakdown_key_of_most_recent_source_event<C>(
     prev_row_breakdown_key_bits: &BitDecomposed<Replicated<Gf2>>,
     cur_row_breakdown_key_bits: &BitDecomposed<Replicated<Gf2>>,
 ) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
+where
+    C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+{
+    field_of_most_recent_source_event(
+        ctx,
+        record_id,
+        is_trigger_bit,
+        prev_row_breakdown_key_bits,
+        cur_row_breakdown_key_bits,
+    )
+    .await
+}
+
+/// Same as above but for timestamps
+async fn timestamp_of_most_recent_source_event<C>(
+    ctx: C,
+    record_id: RecordId,
+    is_trigger_bit: &Replicated<Gf2>,
+    prev_row_timestamp_bits: &BitDecomposed<Replicated<Gf2>>,
+    cur_row_timestamp_bits: &BitDecomposed<Replicated<Gf2>>,
+) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
+where
+    C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+{
+    field_of_most_recent_source_event(
+        ctx,
+        record_id,
+        is_trigger_bit,
+        prev_row_timestamp_bits,
+        cur_row_timestamp_bits,
+    )
+    .await
+}
+
+/// Move a field of the most recent source event down to all of trigger events that follow it.
+///
+/// The logic here is extremely simple. For each row:
+/// (a) if it is a source event, take the current field.
+/// (b) if it is a trigger event, take the field from the preceding line
+async fn field_of_most_recent_source_event<C>(
+    ctx: C,
+    record_id: RecordId,
+    is_trigger_bit: &Replicated<Gf2>,
+    prev_row_field_bits: &BitDecomposed<Replicated<Gf2>>,
+    cur_row_field_bits: &BitDecomposed<Replicated<Gf2>>,
+) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
     Ok(BitDecomposed::new(
         ctx.parallel_join(
-            cur_row_breakdown_key_bits
+            cur_row_field_bits
                 .iter()
-                .zip(prev_row_breakdown_key_bits.iter())
+                .zip(prev_row_field_bits.iter())
                 .enumerate()
                 .map(|(i, (cur_bit, prev_bit))| {
                     let c = ctx.narrow(&BitOpStep::from(i));
@@ -480,6 +590,66 @@ where
     ))
 }
 
+/// If the `attribution_window_seconds` is `None`, then all trigger events are
+/// attributed to the most recent source event. Otherwise, we calculate the time
+/// difference between the trigger event and the most recent source event, and
+/// only attribute the trigger event if it is within the attribution window.
+async fn zero_out_trigger_value_if_outside_attribution_window<C>(
+    ctx: C,
+    record_id: RecordId,
+    attributed_trigger_value: &BitDecomposed<Replicated<Gf2>>,
+    attribution_window_seconds: Option<NonZeroU32>,
+    trigger_event_timestamp: &BitDecomposed<Replicated<Gf2>>,
+    source_event_timestamp: &BitDecomposed<Replicated<Gf2>>,
+) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
+where
+    C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+{
+    if attribution_window_seconds.is_none() {
+        return Ok(attributed_trigger_value.clone());
+    }
+
+    assert_eq!(trigger_event_timestamp.len(), source_event_timestamp.len());
+
+    let attribution_window_seconds = attribution_window_seconds.unwrap().get();
+    let time_delta_bits = trigger_event_timestamp
+        .sub(
+            ctx.narrow(&Step::ComputeTimeDelta),
+            record_id,
+            source_event_timestamp,
+        )
+        .await?;
+
+    // The result is true if the time delta is `[0, attribution_window_seconds)`
+    // If we want to include the upper bound, we need to use `bitwise_greater_than_constant()`
+    // and negate the result.
+    let is_trigger_event_inside_attribution_window = bitwise_less_than_constant(
+        ctx.narrow(&Step::ConvertTimeDeltaBits),
+        record_id,
+        &time_delta_bits,
+        u128::from(attribution_window_seconds),
+    )
+    .await?;
+
+    Ok(BitDecomposed::new(
+        ctx.parallel_join(
+            attributed_trigger_value
+                .iter()
+                .zip(repeat(is_trigger_event_inside_attribution_window))
+                .enumerate()
+                .map(|(i, (trigger_value_bit, is_within_attribution_window))| {
+                    let c = ctx.narrow(&BitOpStep::from(i));
+                    async move {
+                        trigger_value_bit
+                            .multiply(&is_within_attribution_window, c, record_id)
+                            .await
+                    }
+                }),
+        )
+        .await?,
+    ))
+}
+
 ///
 /// To provide a differential privacy guarantee, we need to bound the maximum contribution from any given user to some cap.
 ///
@@ -549,10 +719,11 @@ where
 /// the results per breakdown key
 /// # Errors
 /// If there is an issue in multiplication, it will error
-pub async fn attribution_and_capping_and_aggregation<C, BK, TV, F, S, SB>(
+pub async fn attribution_and_capping_and_aggregation<C, BK, TV, TS, F, S, SB>(
     sh_ctx: C,
-    input_rows: Vec<PrfShardedIpaInputRow<BK, TV>>,
+    input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
     num_saturating_sum_bits: usize,
+    attribution_window_seconds: Option<NonZeroU32>,
 ) -> Result<Vec<S>, Error>
 where
     C: UpgradableContext,
@@ -562,12 +733,18 @@ where
     F: PrimeField + ExtendableField,
     TV: GaloisField,
     BK: GaloisField,
+    TS: GaloisField,
 {
     let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
     let prime_field_m_ctx = prime_field_validator.context();
 
-    let user_level_attributions: Vec<CappedAttributionOutputs> =
-        attribution_and_capping(sh_ctx, input_rows, num_saturating_sum_bits).await?;
+    let user_level_attributions: Vec<CappedAttributionOutputs> = attribution_and_capping(
+        sh_ctx,
+        input_rows,
+        num_saturating_sum_bits,
+        attribution_window_seconds,
+    )
+    .await?;
 
     do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
 }
@@ -617,7 +794,7 @@ where
         0..TV::BITS,
     );
 
-    // tranform value bits to large field
+    // transform value bits to large field
     let large_field_values = converted_values
         .map(|val| BitDecomposed::to_additive_sharing_in_large_field_consuming(val.unwrap()));
 
@@ -662,9 +839,11 @@ where
 
 #[cfg(all(test, unit_test))]
 pub mod tests {
+    use std::num::NonZeroU32;
+
     use super::{attribution_and_capping, CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
-        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf3Bit, Gf5Bit},
+        ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf20Bit, Gf3Bit, Gf5Bit},
         protocol::{
             context::{UpgradableContext, Validator},
             prf_sharding::{attribution_and_capping_and_aggregation, do_aggregation},
@@ -678,11 +857,12 @@ pub mod tests {
         test_fixture::{get_bits, Reconstruct, Runner, TestWorld},
     };
 
-    struct PreShardedAndSortedOPRFTestInput<BK: GaloisField, TV: GaloisField> {
+    struct PreShardedAndSortedOPRFTestInput<BK: GaloisField, TV: GaloisField, TS: GaloisField> {
         prf_of_match_key: u64,
         is_trigger_bit: Gf2,
         breakdown_key: BK,
         trigger_value: TV,
+        timestamp: TS,
     }
 
     fn oprf_test_input(
@@ -690,7 +870,23 @@ pub mod tests {
         is_trigger: bool,
         breakdown_key: u8,
         trigger_value: u8,
-    ) -> PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit> {
+    ) -> PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit, Gf20Bit> {
+        oprf_test_input_with_timestamp(
+            prf_of_match_key,
+            is_trigger,
+            breakdown_key,
+            trigger_value,
+            0,
+        )
+    }
+
+    fn oprf_test_input_with_timestamp(
+        prf_of_match_key: u64,
+        is_trigger: bool,
+        breakdown_key: u8,
+        trigger_value: u8,
+        timestamp: u32,
+    ) -> PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit, Gf20Bit> {
         let is_trigger_bit = if is_trigger { Gf2::ONE } else { Gf2::ZERO };
 
         PreShardedAndSortedOPRFTestInput {
@@ -698,6 +894,7 @@ pub mod tests {
             is_trigger_bit,
             breakdown_key: Gf5Bit::truncate_from(breakdown_key),
             trigger_value: Gf3Bit::truncate_from(trigger_value),
+            timestamp: Gf20Bit::truncate_from(timestamp),
         }
     }
 
@@ -743,23 +940,27 @@ pub mod tests {
         capped_attributed_trigger_value: BitDecomposed<Gf2>,
     }
 
-    impl<BK, TV> IntoShares<PrfShardedIpaInputRow<BK, TV>> for PreShardedAndSortedOPRFTestInput<BK, TV>
+    impl<BK, TV, TS> IntoShares<PrfShardedIpaInputRow<BK, TV, TS>>
+        for PreShardedAndSortedOPRFTestInput<BK, TV, TS>
     where
         BK: GaloisField + IntoShares<Replicated<BK>>,
         TV: GaloisField + IntoShares<Replicated<TV>>,
+        TS: GaloisField + IntoShares<Replicated<TS>>,
     {
-        fn share_with<R: Rng>(self, rng: &mut R) -> [PrfShardedIpaInputRow<BK, TV>; 3] {
+        fn share_with<R: Rng>(self, rng: &mut R) -> [PrfShardedIpaInputRow<BK, TV, TS>; 3] {
             let PreShardedAndSortedOPRFTestInput {
                 prf_of_match_key,
                 is_trigger_bit,
                 breakdown_key,
                 trigger_value,
+                timestamp,
             } = self;
 
             let [is_trigger_bit0, is_trigger_bit1, is_trigger_bit2] =
                 is_trigger_bit.share_with(rng);
             let [breakdown_key0, breakdown_key1, breakdown_key2] = breakdown_key.share_with(rng);
             let [trigger_value0, trigger_value1, trigger_value2] = trigger_value.share_with(rng);
+            let [timestamp0, timestamp1, timestamp2] = timestamp.share_with(rng);
 
             [
                 PrfShardedIpaInputRow {
@@ -767,18 +968,21 @@ pub mod tests {
                     is_trigger_bit: is_trigger_bit0,
                     breakdown_key: breakdown_key0,
                     trigger_value: trigger_value0,
+                    timestamp: timestamp0,
                 },
                 PrfShardedIpaInputRow {
                     prf_of_match_key,
                     is_trigger_bit: is_trigger_bit1,
                     breakdown_key: breakdown_key1,
                     trigger_value: trigger_value1,
+                    timestamp: timestamp1,
                 },
                 PrfShardedIpaInputRow {
                     prf_of_match_key,
                     is_trigger_bit: is_trigger_bit2,
                     breakdown_key: breakdown_key2,
                     trigger_value: trigger_value2,
+                    timestamp: timestamp2,
                 },
             ]
         }
@@ -853,11 +1057,11 @@ pub mod tests {
     }
 
     #[test]
-    fn semi_honest_attribution_and_capping() {
+    fn semi_honest_attribution_and_capping_no_attribution_window() {
         run(|| async move {
             let world = TestWorld::default();
 
-            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit>> = vec![
+            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit, Gf20Bit>> = vec![
                 /* First User */
                 oprf_test_input(123, false, 17, 0),
                 oprf_test_input(123, true, 0, 7),
@@ -894,10 +1098,69 @@ pub mod tests {
 
             let result: Vec<_> = world
                 .semi_honest(records.into_iter(), |ctx, input_rows| async move {
-                    attribution_and_capping::<_, Gf5Bit, Gf3Bit>(
+                    attribution_and_capping::<_, Gf5Bit, Gf3Bit, Gf20Bit>(
+                        ctx,
+                        input_rows,
+                        num_saturating_bits,
+                        None,
+                    )
+                    .await
+                    .unwrap()
+                })
+                .await
+                .reconstruct();
+            assert_eq!(result, &expected);
+        });
+    }
+
+    #[test]
+    fn semi_honest_with_attribution_window() {
+        run(|| async move {
+            let world = TestWorld::default();
+
+            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit, Gf20Bit>> = vec![
+                /* First User */
+                oprf_test_input_with_timestamp(123, false, 17, 0, 0),
+                oprf_test_input_with_timestamp(123, true, 0, 7, 100),
+                oprf_test_input_with_timestamp(123, false, 20, 0, 200),
+                oprf_test_input_with_timestamp(123, true, 0, 3, 300),
+                /* Second User */
+                oprf_test_input_with_timestamp(234, false, 12, 0, 0),
+                oprf_test_input_with_timestamp(234, true, 0, 5, 100),
+                /* Third User */
+                oprf_test_input_with_timestamp(345, false, 20, 0, 0),
+                oprf_test_input_with_timestamp(345, true, 0, 7, 100),
+                oprf_test_input_with_timestamp(345, false, 18, 0, 200),
+                oprf_test_input_with_timestamp(345, false, 12, 0, 300),
+                oprf_test_input_with_timestamp(345, true, 0, 7, 400),
+                oprf_test_input_with_timestamp(345, true, 0, 7, 499),
+                // all the following events are ignored if the attribution window is <= 200s
+                oprf_test_input_with_timestamp(345, true, 0, 7, 600),
+                oprf_test_input_with_timestamp(345, true, 0, 7, 700),
+            ];
+
+            let expected: [PreAggregationTestOutputInDecimal; 11] = [
+                decimal_bd_key_and_value(17, 7),
+                decimal_bd_key_and_value(20, 0),
+                decimal_bd_key_and_value(20, 3),
+                decimal_bd_key_and_value(12, 5),
+                decimal_bd_key_and_value(20, 7),
+                decimal_bd_key_and_value(18, 0),
+                decimal_bd_key_and_value(12, 0),
+                decimal_bd_key_and_value(12, 7),
+                decimal_bd_key_and_value(12, 7),
+                decimal_bd_key_and_value(12, 0),
+                decimal_bd_key_and_value(12, 0),
+            ];
+            let num_saturating_bits: usize = 5;
+
+            let result: Vec<_> = world
+                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
+                    attribution_and_capping::<_, Gf5Bit, Gf3Bit, Gf20Bit>(
                         ctx,
                         input_rows,
                         num_saturating_bits,
+                        Some(NonZeroU32::new(200).unwrap()),
                     )
                     .await
                     .unwrap()
@@ -913,7 +1176,7 @@ pub mod tests {
         run(|| async move {
             let world = TestWorld::default();
 
-            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit>> = vec![
+            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit, Gf20Bit>> = vec![
                 /* First User */
                 oprf_test_input(123, false, 17, 0),
                 oprf_test_input(123, true, 0, 7),
@@ -946,10 +1209,11 @@ pub mod tests {
                         _,
                         Gf5Bit,
                         Gf3Bit,
+                        Gf20Bit,
                         Fp32BitPrime,
                         _,
                         Replicated<Gf2>,
-                    >(ctx, input_rows, num_saturating_bits)
+                    >(ctx, input_rows, num_saturating_bits, None)
                     .await
                     .unwrap()
                 })
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 6a3f7d28d..c3be6be81 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -2,7 +2,11 @@ use std::{fmt::Debug, ops::Deref};
 
 use crate::{
     error::Error,
-    ff::PrimeField,
+    ff::{Field, Gf2, PrimeField},
+    protocol::{
+        boolean::saturating_sum::one_bit_subtractor, context::Context, step::BitOpStep,
+        BasicProtocols, RecordId,
+    },
     secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
 };
 
@@ -79,6 +83,46 @@ impl<S> BitDecomposed<S> {
             acc + (b * F::truncate_from(1_u128 << i))
         })
     }
+
+    /// Subtraction of two bit-wise secret shares, `self - rhs`, in two's complement.
+    /// Subtracting a value larger than `self` value will cause the result to overflow.
+    /// Be especially careful as the overflow is not checked and could lead to a privacy
+    /// violation (e.g., invalid capping).
+    ///
+    /// # Errors
+    /// If one of the multiplications errors
+    /// # Panics
+    /// If something try to add a bit decomposed value larger than this `SaturatingSum` can accommodate
+    pub async fn sub<C>(
+        &self,
+        ctx: C,
+        record_id: RecordId,
+        rhs: &BitDecomposed<S>,
+    ) -> Result<BitDecomposed<S>, Error>
+    where
+        C: Context,
+        S: LinearSecretSharing<Gf2> + BasicProtocols<C, Gf2>,
+        for<'a> &'a S: LinearRefOps<'a, S, Gf2>,
+    {
+        assert!(self.len() >= rhs.len());
+
+        let mut output = vec![];
+        let mut carry_in = S::share_known_value(&ctx, Gf2::ONE);
+        let zero = S::ZERO;
+        for i in 0..self.len() {
+            let c = ctx.narrow(&BitOpStep::from(i));
+            let compute_carry_out = i < self.len() - 1;
+            let lfs = &self[i];
+            let rhs = rhs.get(i).unwrap_or(&zero);
+            let difference_bit =
+                one_bit_subtractor(c, record_id, lfs, rhs, &mut carry_in, compute_carry_out)
+                    .await?;
+
+            output.push(difference_bit);
+        }
+
+        Ok(BitDecomposed::new(output))
+    }
 }
 
 impl<S> TryFrom<Vec<S>> for BitDecomposed<S> {
@@ -106,3 +150,54 @@ impl<S> IntoIterator for BitDecomposed<S> {
         self.bits.into_iter()
     }
 }
+
+#[cfg(all(test, unit_test))]
+mod tests {
+    use crate::{
+        ff::Gf2,
+        protocol::{context::Context, RecordId},
+        secret_sharing::BitDecomposed,
+        test_fixture::{get_bits, Reconstruct, Runner, TestWorld},
+    };
+
+    #[tokio::test]
+    pub async fn subtraction() {
+        // `lhs >= rhs`
+        assert_eq!(0, subtract(1, 2, 1, 2).await);
+        assert_eq!(1, subtract(2, 2, 1, 2).await);
+        assert_eq!(1, subtract(3, 2, 2, 2).await);
+        assert_eq!(2, subtract(3, 2, 1, 2).await);
+        assert_eq!(3, subtract(3, 2, 0, 2).await);
+        assert_eq!(2, subtract(3, 5, 1, 5).await);
+        assert_eq!(6, subtract(7, 5, 1, 2).await);
+        assert_eq!(6, subtract(7, 5, 1, 5).await);
+
+        // `lhs < rhs` so the result is an unsigned integer in two's complement
+        // representation in whatever many bits of the `lhs`
+        assert_eq!(3, subtract(0, 2, 1, 2).await);
+        assert_eq!(31, subtract(1, 5, 2, 2).await);
+        assert_eq!(30, subtract(1, 5, 3, 2).await);
+        assert_eq!(26, subtract(1, 5, 7, 5).await);
+    }
+
+    async fn subtract(a: u32, num_a_bits: u32, b: u32, num_b_bits: u32) -> u128 {
+        let world = TestWorld::default();
+
+        let a_bits = get_bits::<Gf2>(a, num_a_bits);
+        let b_bits = get_bits::<Gf2>(b, num_b_bits);
+
+        let foo = world
+            .semi_honest(
+                (a_bits, b_bits),
+                |ctx, (a_bits, b_bits): (BitDecomposed<_>, BitDecomposed<_>)| async move {
+                    a_bits
+                        .sub(ctx.set_total_records(1), RecordId::from(0), &b_bits)
+                        .await
+                        .unwrap()
+                },
+            )
+            .await;
+
+        foo.reconstruct()
+    }
+}

From 141a6b16898bc94edde8657834a36daab31c737e Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Thu, 19 Oct 2023 17:21:59 +0800
Subject: [PATCH 054/105] Optimize by removing redundant multiplications

---
 src/protocol/prf_sharding/mod.rs | 147 +++++++++++++++----------------
 src/secret_sharing/decomposed.rs |   6 +-
 2 files changed, 75 insertions(+), 78 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 39ab0c1ac..649c36a9e 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -4,7 +4,10 @@ use std::{
 };
 
 use futures::{stream::iter as stream_iter, TryStreamExt};
-use futures_util::{future::try_join, StreamExt};
+use futures_util::{
+    future::{try_join, try_join3},
+    StreamExt,
+};
 use ipa_macros::Step;
 
 use super::boolean::saturating_sum::SaturatingSum;
@@ -120,7 +123,11 @@ impl InputsRequiredFromPrevRow {
         let share_of_one = Replicated::share_known_value(&ctx, Gf2::ONE);
         let is_source_event = &share_of_one - &input_row.is_trigger_bit;
 
-        let (ever_encountered_a_source_event, attributed_breakdown_key_bits) = try_join(
+        let (
+            ever_encountered_a_source_event,
+            attributed_breakdown_key_bits,
+            source_event_timestamp,
+        ) = try_join3(
             or(
                 ctx.narrow(&Step::EverEncounteredSourceEvent),
                 record_id,
@@ -134,50 +141,42 @@ impl InputsRequiredFromPrevRow {
                 &self.attributed_breakdown_key_bits,
                 &bd_key,
             ),
+            timestamp_of_most_recent_source_event(
+                ctx.narrow(&Step::SourceEventTimestamp),
+                record_id,
+                attribution_window_seconds,
+                &input_row.is_trigger_bit,
+                &self.source_event_timestamp,
+                &timestamp,
+            ),
         )
         .await?;
 
-        let source_event_timestamp = match attribution_window_seconds {
-            None => self.source_event_timestamp.clone(),
-            Some(_) => {
-                timestamp_of_most_recent_source_event(
-                    ctx.narrow(&Step::SourceEventTimestamp),
-                    record_id,
-                    &input_row.is_trigger_bit,
-                    &self.source_event_timestamp,
-                    &timestamp,
-                )
-                .await?
-            }
-        };
-
-        let did_trigger_get_attributed = input_row
-            .is_trigger_bit
-            .multiply(
+        let (did_trigger_get_attributed, is_trigger_within_window) = try_join(
+            input_row.is_trigger_bit.multiply(
                 &ever_encountered_a_source_event,
                 ctx.narrow(&Step::DidTriggerGetAttributed),
                 record_id,
-            )
-            .await?;
+            ),
+            is_trigger_event_within_attribution_window(
+                ctx.narrow(&Step::CheckAttributionWindow),
+                record_id,
+                attribution_window_seconds,
+                &timestamp,
+                &source_event_timestamp,
+            ),
+        )
+        .await?;
 
-        let mut attributed_trigger_value = zero_out_trigger_value_unless_attributed(
+        let attributed_trigger_value = zero_out_trigger_value_unless_attributed(
             ctx.narrow(&Step::AttributedTriggerValue),
             record_id,
             &did_trigger_get_attributed,
+            &is_trigger_within_window,
             &tv,
         )
         .await?;
 
-        attributed_trigger_value = zero_out_trigger_value_if_outside_attribution_window(
-            ctx.narrow(&Step::CheckAttributionWindow),
-            record_id,
-            &attributed_trigger_value,
-            attribution_window_seconds,
-            &timestamp,
-            &source_event_timestamp,
-        )
-        .await?;
-
         let updated_sum = self
             .saturating_sum
             .add(
@@ -264,9 +263,10 @@ pub(crate) enum Step {
     DidTriggerGetAttributed,
     AttributedBreakdownKey,
     AttributedTriggerValue,
+    AttributedEventCheckFlag,
     CheckAttributionWindow,
     ComputeTimeDelta,
-    ConvertTimeDeltaBits,
+    CompareTimeDeltaToAttributionWindow,
     SourceEventTimestamp,
     ComputeSaturatingSum,
     IsSaturatedAndPrevRowNotSaturated,
@@ -503,10 +503,12 @@ where
     .await
 }
 
-/// Same as above but for timestamps
+/// Same as above but for timestamps. If `attribution_window_seconds` is `None`, just
+/// return the previous row's timestamp. The bits aren't used but saves some multiplications.
 async fn timestamp_of_most_recent_source_event<C>(
     ctx: C,
     record_id: RecordId,
+    attribution_window_seconds: Option<NonZeroU32>,
     is_trigger_bit: &Replicated<Gf2>,
     prev_row_timestamp_bits: &BitDecomposed<Replicated<Gf2>>,
     cur_row_timestamp_bits: &BitDecomposed<Replicated<Gf2>>,
@@ -514,14 +516,19 @@ async fn timestamp_of_most_recent_source_event<C>(
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
-    field_of_most_recent_source_event(
-        ctx,
-        record_id,
-        is_trigger_bit,
-        prev_row_timestamp_bits,
-        cur_row_timestamp_bits,
-    )
-    .await
+    match attribution_window_seconds {
+        None => Ok(prev_row_timestamp_bits.clone()),
+        Some(_) => {
+            field_of_most_recent_source_event(
+                ctx,
+                record_id,
+                is_trigger_bit,
+                prev_row_timestamp_bits,
+                cur_row_timestamp_bits,
+            )
+            .await
+        }
+    }
 }
 
 /// Move a field of the most recent source event down to all of trigger events that follow it.
@@ -559,29 +566,36 @@ where
 /// (a) Attributed to a single `breakdown_key`
 /// (b) Not attributed, and thus zeroed out
 ///
-/// The logic here is extremely simple. There is a secret-shared bit indicating if a given row is an "attributed trigger event"
-/// The bits of the `trigger_value` are all multiplied by this bit in order to zero out contributions from unattributed trigger events
+/// The logic here is extremely simple. There is a secret-shared bit indicating if a given row is an "attributed trigger event" and
+/// another secret-shared bit indicating if a given row is within the attribution window. We multiply these two bits together and
+/// multiply it with the bits of the `trigger_value` in order to zero out contributions from unattributed trigger events.
 ///
 async fn zero_out_trigger_value_unless_attributed<C>(
     ctx: C,
     record_id: RecordId,
     did_trigger_get_attributed: &Replicated<Gf2>,
+    is_trigger_within_window: &Replicated<Gf2>,
     trigger_value: &BitDecomposed<Replicated<Gf2>>,
 ) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
+    let c = ctx.narrow(&Step::AttributedEventCheckFlag);
+    let zero_out_flag = &did_trigger_get_attributed
+        .multiply(is_trigger_within_window, c, record_id)
+        .await?;
+
     Ok(BitDecomposed::new(
         ctx.parallel_join(
             trigger_value
                 .iter()
-                .zip(repeat(did_trigger_get_attributed))
+                .zip(repeat(zero_out_flag))
                 .enumerate()
-                .map(|(i, (trigger_value_bit, did_trigger_get_attributed))| {
+                .map(|(i, (trigger_value_bit, zero_out_flag))| {
                     let c = ctx.narrow(&BitOpStep::from(i));
                     async move {
                         trigger_value_bit
-                            .multiply(did_trigger_get_attributed, c, record_id)
+                            .multiply(zero_out_flag, c, record_id)
                             .await
                     }
                 }),
@@ -590,23 +604,24 @@ where
     ))
 }
 
-/// If the `attribution_window_seconds` is `None`, then all trigger events are
-/// attributed to the most recent source event. Otherwise, we calculate the time
+/// If the `attribution_window_seconds` is not `None`, we calculate the time
 /// difference between the trigger event and the most recent source event, and
-/// only attribute the trigger event if it is within the attribution window.
-async fn zero_out_trigger_value_if_outside_attribution_window<C>(
+/// returns a secret-shared bit indicating if the trigger event is within the
+/// attribution window.
+async fn is_trigger_event_within_attribution_window<C>(
     ctx: C,
     record_id: RecordId,
-    attributed_trigger_value: &BitDecomposed<Replicated<Gf2>>,
     attribution_window_seconds: Option<NonZeroU32>,
     trigger_event_timestamp: &BitDecomposed<Replicated<Gf2>>,
     source_event_timestamp: &BitDecomposed<Replicated<Gf2>>,
-) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
+) -> Result<Replicated<Gf2>, Error>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
+    // if there is no attribution window, then all trigger events are attributed
     if attribution_window_seconds.is_none() {
-        return Ok(attributed_trigger_value.clone());
+        let share_of_one = Replicated::share_known_value(&ctx, Gf2::ONE);
+        return Ok(share_of_one);
     }
 
     assert_eq!(trigger_event_timestamp.len(), source_event_timestamp.len());
@@ -623,31 +638,13 @@ where
     // The result is true if the time delta is `[0, attribution_window_seconds)`
     // If we want to include the upper bound, we need to use `bitwise_greater_than_constant()`
     // and negate the result.
-    let is_trigger_event_inside_attribution_window = bitwise_less_than_constant(
-        ctx.narrow(&Step::ConvertTimeDeltaBits),
+    bitwise_less_than_constant(
+        ctx.narrow(&Step::CompareTimeDeltaToAttributionWindow),
         record_id,
         &time_delta_bits,
         u128::from(attribution_window_seconds),
     )
-    .await?;
-
-    Ok(BitDecomposed::new(
-        ctx.parallel_join(
-            attributed_trigger_value
-                .iter()
-                .zip(repeat(is_trigger_event_inside_attribution_window))
-                .enumerate()
-                .map(|(i, (trigger_value_bit, is_within_attribution_window))| {
-                    let c = ctx.narrow(&BitOpStep::from(i));
-                    async move {
-                        trigger_value_bit
-                            .multiply(&is_within_attribution_window, c, record_id)
-                            .await
-                    }
-                }),
-        )
-        .await?,
-    ))
+    .await
 }
 
 ///
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index c3be6be81..7e9025455 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -92,7 +92,7 @@ impl<S> BitDecomposed<S> {
     /// # Errors
     /// If one of the multiplications errors
     /// # Panics
-    /// If something try to add a bit decomposed value larger than this `SaturatingSum` can accommodate
+    /// If something try to subtract a bit decomposed value larger than this `BitDecomposed` can accommodate
     pub async fn sub<C>(
         &self,
         ctx: C,
@@ -112,10 +112,10 @@ impl<S> BitDecomposed<S> {
         for i in 0..self.len() {
             let c = ctx.narrow(&BitOpStep::from(i));
             let compute_carry_out = i < self.len() - 1;
-            let lfs = &self[i];
+            let lhs = &self[i];
             let rhs = rhs.get(i).unwrap_or(&zero);
             let difference_bit =
-                one_bit_subtractor(c, record_id, lfs, rhs, &mut carry_in, compute_carry_out)
+                one_bit_subtractor(c, record_id, lhs, rhs, &mut carry_in, compute_carry_out)
                     .await?;
 
             output.push(difference_bit);

From 946a9ee211bed9a75d357046d3caa883ba0208ba Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Fri, 20 Oct 2023 12:46:57 +0800
Subject: [PATCH 055/105] save one more multiplication

---
 src/protocol/prf_sharding/mod.rs | 141 +++++++++++++++----------------
 1 file changed, 66 insertions(+), 75 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 649c36a9e..aec7bee85 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -174,6 +174,7 @@ impl InputsRequiredFromPrevRow {
             &did_trigger_get_attributed,
             &is_trigger_within_window,
             &tv,
+            attribution_window_seconds,
         )
         .await?;
 
@@ -483,6 +484,9 @@ where
 /// To support "Last Touch Attribution" we move the `breakdown_key` of the most recent source event
 /// down to all of trigger events that follow it.
 ///
+/// The logic here is extremely simple. For each row:
+/// (a) if it is a source event, take the current `breakdown_key`.
+/// (b) if it is a trigger event, take the `breakdown_key` from the preceding line
 async fn breakdown_key_of_most_recent_source_event<C>(
     ctx: C,
     record_id: RecordId,
@@ -493,14 +497,19 @@ async fn breakdown_key_of_most_recent_source_event<C>(
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
-    field_of_most_recent_source_event(
-        ctx,
-        record_id,
-        is_trigger_bit,
-        prev_row_breakdown_key_bits,
-        cur_row_breakdown_key_bits,
-    )
-    .await
+    Ok(BitDecomposed::new(
+        ctx.parallel_join(
+            cur_row_breakdown_key_bits
+                .iter()
+                .zip(prev_row_breakdown_key_bits.iter())
+                .enumerate()
+                .map(|(i, (cur_bit, prev_bit))| {
+                    let c = ctx.narrow(&BitOpStep::from(i));
+                    async move { if_else(c, record_id, is_trigger_bit, prev_bit, cur_bit).await }
+                }),
+        )
+        .await?,
+    ))
 }
 
 /// Same as above but for timestamps. If `attribution_window_seconds` is `None`, just
@@ -519,48 +528,26 @@ where
     match attribution_window_seconds {
         None => Ok(prev_row_timestamp_bits.clone()),
         Some(_) => {
-            field_of_most_recent_source_event(
-                ctx,
-                record_id,
-                is_trigger_bit,
-                prev_row_timestamp_bits,
-                cur_row_timestamp_bits,
-            )
-            .await
+            Ok(BitDecomposed::new(
+                ctx
+                    .parallel_join(
+                        cur_row_timestamp_bits
+                            .iter()
+                            .zip(prev_row_timestamp_bits.iter())
+                            .enumerate()
+                            .map(|(i, (cur_bit, prev_bit))| {
+                                let c = ctx.narrow(&BitOpStep::from(i));
+                                async move {
+                                    if_else(c, record_id, is_trigger_bit, prev_bit, cur_bit).await
+                                }
+                            }),
+                    )
+                    .await?,
+            ))
         }
     }
 }
 
-/// Move a field of the most recent source event down to all of trigger events that follow it.
-///
-/// The logic here is extremely simple. For each row:
-/// (a) if it is a source event, take the current field.
-/// (b) if it is a trigger event, take the field from the preceding line
-async fn field_of_most_recent_source_event<C>(
-    ctx: C,
-    record_id: RecordId,
-    is_trigger_bit: &Replicated<Gf2>,
-    prev_row_field_bits: &BitDecomposed<Replicated<Gf2>>,
-    cur_row_field_bits: &BitDecomposed<Replicated<Gf2>>,
-) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
-where
-    C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
-{
-    Ok(BitDecomposed::new(
-        ctx.parallel_join(
-            cur_row_field_bits
-                .iter()
-                .zip(prev_row_field_bits.iter())
-                .enumerate()
-                .map(|(i, (cur_bit, prev_bit))| {
-                    let c = ctx.narrow(&BitOpStep::from(i));
-                    async move { if_else(c, record_id, is_trigger_bit, prev_bit, cur_bit).await }
-                }),
-        )
-        .await?,
-    ))
-}
-
 ///
 /// In this simple "Last Touch Attribution" model, the `trigger_value` of a trigger event is either
 /// (a) Attributed to a single `breakdown_key`
@@ -576,14 +563,20 @@ async fn zero_out_trigger_value_unless_attributed<C>(
     did_trigger_get_attributed: &Replicated<Gf2>,
     is_trigger_within_window: &Replicated<Gf2>,
     trigger_value: &BitDecomposed<Replicated<Gf2>>,
+    attribution_window_seconds: Option<NonZeroU32>,
 ) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
-    let c = ctx.narrow(&Step::AttributedEventCheckFlag);
-    let zero_out_flag = &did_trigger_get_attributed
-        .multiply(is_trigger_within_window, c, record_id)
-        .await?;
+    // save 1 multiplication if there is no attribution window
+    let zero_out_flag = if attribution_window_seconds.is_some() {
+        let c = ctx.narrow(&Step::AttributedEventCheckFlag);
+        did_trigger_get_attributed
+            .multiply(is_trigger_within_window, c, record_id)
+            .await?
+    } else {
+        did_trigger_get_attributed.clone()
+    };
 
     Ok(BitDecomposed::new(
         ctx.parallel_join(
@@ -595,7 +588,7 @@ where
                     let c = ctx.narrow(&BitOpStep::from(i));
                     async move {
                         trigger_value_bit
-                            .multiply(zero_out_flag, c, record_id)
+                            .multiply(&zero_out_flag, c, record_id)
                             .await
                     }
                 }),
@@ -618,33 +611,31 @@ async fn is_trigger_event_within_attribution_window<C>(
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
-    // if there is no attribution window, then all trigger events are attributed
-    if attribution_window_seconds.is_none() {
-        let share_of_one = Replicated::share_known_value(&ctx, Gf2::ONE);
-        return Ok(share_of_one);
-    }
+    if let Some(attribution_window_seconds) = attribution_window_seconds {
+        assert_eq!(trigger_event_timestamp.len(), source_event_timestamp.len());
 
-    assert_eq!(trigger_event_timestamp.len(), source_event_timestamp.len());
+        let time_delta_bits = trigger_event_timestamp
+            .sub(
+                ctx.narrow(&Step::ComputeTimeDelta),
+                record_id,
+                source_event_timestamp,
+            )
+            .await?;
 
-    let attribution_window_seconds = attribution_window_seconds.unwrap().get();
-    let time_delta_bits = trigger_event_timestamp
-        .sub(
-            ctx.narrow(&Step::ComputeTimeDelta),
+        // The result is true if the time delta is `[0, attribution_window_seconds)`
+        // If we want to include the upper bound, we need to use `bitwise_greater_than_constant()`
+        // and negate the result.
+        bitwise_less_than_constant(
+            ctx.narrow(&Step::CompareTimeDeltaToAttributionWindow),
             record_id,
-            source_event_timestamp,
+            &time_delta_bits,
+            u128::from(attribution_window_seconds.get()),
         )
-        .await?;
-
-    // The result is true if the time delta is `[0, attribution_window_seconds)`
-    // If we want to include the upper bound, we need to use `bitwise_greater_than_constant()`
-    // and negate the result.
-    bitwise_less_than_constant(
-        ctx.narrow(&Step::CompareTimeDeltaToAttributionWindow),
-        record_id,
-        &time_delta_bits,
-        u128::from(attribution_window_seconds),
-    )
-    .await
+        .await
+    } else {
+        // if there is no attribution window, then all trigger events are attributed
+        Ok(Replicated::share_known_value(&ctx, Gf2::ONE))
+    }
 }
 
 ///
@@ -1157,7 +1148,7 @@ pub mod tests {
                         ctx,
                         input_rows,
                         num_saturating_bits,
-                        Some(NonZeroU32::new(200).unwrap()),
+                        NonZeroU32::new(200),
                     )
                     .await
                     .unwrap()

From a5d3587aa6ad4e72f3f5db73d5d55c749c91fac5 Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Fri, 20 Oct 2023 12:53:25 +0800
Subject: [PATCH 056/105] inline the variables

---
 src/secret_sharing/decomposed.rs | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 7e9025455..1fc87d2c6 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -112,11 +112,15 @@ impl<S> BitDecomposed<S> {
         for i in 0..self.len() {
             let c = ctx.narrow(&BitOpStep::from(i));
             let compute_carry_out = i < self.len() - 1;
-            let lhs = &self[i];
-            let rhs = rhs.get(i).unwrap_or(&zero);
-            let difference_bit =
-                one_bit_subtractor(c, record_id, lhs, rhs, &mut carry_in, compute_carry_out)
-                    .await?;
+            let difference_bit = one_bit_subtractor(
+                c,
+                record_id,
+                &self[i],
+                rhs.get(i).unwrap_or(&zero),
+                &mut carry_in,
+                compute_carry_out,
+            )
+            .await?;
 
             output.push(difference_bit);
         }

From 3ef3e7e392c3c159fc5546bbd16514d7b429b567 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <akoshelev@users.noreply.github.com>
Date: Thu, 19 Oct 2023 23:54:53 -0700
Subject: [PATCH 057/105] Upgrade dependencies (#811)

---
 Cargo.toml                                    | 32 +++++++++++--------
 src/bin/test_mpc.rs                           |  2 +-
 src/cli/keygen.rs                             |  6 ++--
 src/cli/playbook/multiply.rs                  |  2 +-
 src/config.rs                                 |  2 +-
 src/ff/mod.rs                                 |  2 +-
 src/helpers/transport/stream/input.rs         | 10 +++---
 src/hpke/mod.rs                               |  7 ++--
 src/hpke/registry.rs                          |  8 ++---
 src/net/client/mod.rs                         |  5 +--
 src/net/server/mod.rs                         | 22 +++++--------
 src/net/test.rs                               |  2 +-
 src/protocol/aggregation/input.rs             |  2 +-
 src/protocol/ipa/mod.rs                       |  2 +-
 src/protocol/prss/crypto.rs                   |  2 +-
 src/report.rs                                 |  2 +-
 src/secret_sharing/mod.rs                     |  2 +-
 .../replicated/malicious/additive_share.rs    |  2 +-
 .../replicated/semi_honest/additive_share.rs  |  2 +-
 19 files changed, 56 insertions(+), 58 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9e4314b41..1767e8e24 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,7 +19,7 @@ enable-serde = ["serde", "serde_json"]
 disable-metrics = []
 # TODO move web-app to a separate crate. It adds a lot of build time to people who mostly write protocols
 # TODO Consider moving out benches as well
-web-app = ["axum", "axum-server", "base64", "clap", "comfy-table", "enable-serde", "hyper", "hyper-rustls", "rcgen", "rustls-pemfile", "time", "tokio-rustls", "toml", "tower", "tower-http"]
+web-app = ["axum", "axum-server", "base64", "clap", "comfy-table", "enable-serde", "hyper", "hyper-rustls", "rcgen", "rustls", "rustls-pemfile", "time", "tokio-rustls", "toml", "tower", "tower-http"]
 test-fixture = ["enable-serde", "weak-field"]
 shuttle = ["shuttle-crate", "test-fixture"]
 debug-trace = ["tracing/max_level_trace", "tracing/release_max_level_debug"]
@@ -43,7 +43,6 @@ compact-gate = ["ipa-macros/compact-gate"]
 aggregate-circuit = []
 
 [dependencies]
-ipa-macros = { version = "*", path = "./ipa-macros" }
 aes = "0.8.3"
 async-trait = "0.1.68"
 axum = { version = "0.5.17", optional = true, features = ["http2"] }
@@ -60,13 +59,14 @@ dhat = "0.3.2"
 embed-doc-image = "0.1.4"
 futures = "0.3.28"
 futures-util = "0.3.28"
-generic-array = "0.14.7"
+generic-array = "1.0.0"
 hex = { version = "0.4", features = ["serde"] }
 hkdf = "0.12.3"
-hpke = { version = "0.10.0", default-features = false, features = ["std", "x25519-dalek"] }
+hpke = { version = "0.11.0", default-features = false, features = ["std", "x25519"] }
 hyper = { version = "0.14.26", optional = true, features = ["client", "h2", "stream", "runtime"] }
-hyper-rustls = { version = "0.24.0", optional = true, features = ["http2"] }
+hyper-rustls = { version = "0.24.1", optional = true, features = ["http2"] }
 iai = { version = "0.1.1", optional = true }
+ipa-macros = { version = "*", path = "./ipa-macros" }
 metrics = "0.21.0"
 metrics-tracing-context = "0.14.0"
 metrics-util = { version = "0.15.0" }
@@ -74,27 +74,31 @@ once_cell = "1.18"
 pin-project = "1.0"
 rand = "0.8"
 rand_core = "0.6"
-rcgen = { version = "0.10", optional = true }
-rustls = "0.21.5"
+rcgen = { version = "0.11.3", optional = true }
+rustls = { version = "0.21", optional = true }
 rustls-pemfile = { version = "1", optional = true }
+# TODO: https://rustsec.org/advisories/RUSTSEC-2023-0053. tokio-rustls and hyper-rustls need to be upgraded first, before
+# we can remove pinning
+rustls-webpki = "^0.101.4"
 # TODO consider using zerocopy or serde_bytes or in-house serialization
 serde = { version = "1.0", optional = true, features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
-sha2 = "0.10.6"
+sha2 = "0.10"
 shuttle-crate = { package = "shuttle", version = "0.6.1", optional = true }
 thiserror = "1.0"
 time = { version = "0.3", optional = true }
 tokio = { version = "1.28", features = ["rt", "rt-multi-thread", "macros"] }
-tokio-rustls = { version = "0.24.0", optional = true }
+# TODO: axum-server holds onto 0.24 and we can't upgrade until they do. Or we move away from axum-server
+tokio-rustls = { version = "0.24", optional = true }
 tokio-stream = "0.1.14"
-toml = { version = "0.7", optional = true }
+toml = { version = "0.8", optional = true }
 tower = { version = "0.4.13", optional = true }
 tower-http = { version = "0.4.0", optional = true, features = ["trace"] }
-tracing = "0.1.37"
-tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 typenum = "1.16"
 # hpke is pinned to it
-x25519-dalek = "2.0.0-pre.0"
+x25519-dalek = "2.0.0-rc.3"
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 tikv-jemallocator = "0.5.0"
@@ -107,8 +111,8 @@ command-fds = "0.2.2"
 hex = "0.4"
 permutation = "0.4.1"
 proptest = "1"
+rustls = { version = "0.21", features = ["dangerous_configuration"] }
 tempfile = "3"
-tokio-rustls = { version = "0.24.0", features = ["dangerous_configuration"] }
 
 [profile.release]
 incremental = true
diff --git a/src/bin/test_mpc.rs b/src/bin/test_mpc.rs
index edee8d82d..ce4172df3 100644
--- a/src/bin/test_mpc.rs
+++ b/src/bin/test_mpc.rs
@@ -103,7 +103,7 @@ async fn multiply_in_field<F: Field>(args: &Args, helper_clients: &[MpcHelperCli
 where
     F: Field + IntoShares<AdditiveShare<F>>,
     <F as Serializable>::Size: Add<<F as Serializable>::Size>,
-    <<F as Serializable>::Size as Add<<F as Serializable>::Size>>::Output: ArrayLength<u8>,
+    <<F as Serializable>::Size as Add<<F as Serializable>::Size>>::Output: ArrayLength,
 {
     let input = InputSource::from(&args.input);
     let input_rows = input.iter::<(F, F)>().collect::<Vec<_>>();
diff --git a/src/cli/keygen.rs b/src/cli/keygen.rs
index a32c30ac3..7c8c68fa7 100644
--- a/src/cli/keygen.rs
+++ b/src/cli/keygen.rs
@@ -9,7 +9,7 @@ use rand::{thread_rng, Rng};
 use rand_core::CryptoRng;
 use rcgen::{
     Certificate, CertificateParams, DistinguishedName, ExtendedKeyUsagePurpose, IsCa,
-    KeyUsagePurpose, SanType, PKCS_ECDSA_P256_SHA256,
+    KeyUsagePurpose, SanType, SerialNumber, PKCS_ECDSA_P256_SHA256,
 };
 use time::{Duration, OffsetDateTime};
 
@@ -75,7 +75,9 @@ pub fn keygen_tls<R: Rng + CryptoRng>(args: &KeygenArgs, rng: &mut R) -> Result<
     ];
     params.not_before = OffsetDateTime::now_utc() - Duration::days(1);
     params.not_after = params.not_before + Duration::days(91);
-    params.serial_number = Some(rng.gen_range(0..=i64::MAX.try_into().unwrap()));
+    params.serial_number = Some(SerialNumber::from(
+        rng.gen_range(0..=i64::MAX.try_into().unwrap()),
+    ));
 
     let mut name = DistinguishedName::new();
     name.push(rcgen::DnType::CommonName, args.name.clone());
diff --git a/src/cli/playbook/multiply.rs b/src/cli/playbook/multiply.rs
index caadd8d7b..cc16e1c3c 100644
--- a/src/cli/playbook/multiply.rs
+++ b/src/cli/playbook/multiply.rs
@@ -27,7 +27,7 @@ pub async fn secure_mul<F>(
 where
     F: Field + IntoShares<Replicated<F>>,
     <F as Serializable>::Size: Add<<F as Serializable>::Size>,
-    <<F as Serializable>::Size as Add<<F as Serializable>::Size>>::Output: ArrayLength<u8>,
+    <<F as Serializable>::Size as Add<<F as Serializable>::Size>>::Output: ArrayLength,
 {
     // prepare inputs
     let inputs = input.into_iter().share().map(|vec| {
diff --git a/src/config.rs b/src/config.rs
index 24db8d149..7794666d2 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -9,10 +9,10 @@ use std::{
 };
 
 use hyper::{client::Builder, http::uri::Scheme, Uri};
+use rustls::Certificate;
 use rustls_pemfile::Item;
 use serde::{Deserialize, Deserializer, Serialize};
 use tokio::fs;
-use tokio_rustls::rustls::Certificate;
 
 use crate::{
     error::BoxError,
diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 3a47dc5e0..5544f2378 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -38,7 +38,7 @@ impl<T, Rhs> AddSubAssign<Rhs> for T where T: AddAssign<Rhs> + SubAssign<Rhs> {}
 /// Trait for items that have fixed-byte length representation.
 pub trait Serializable: Sized {
     /// Required number of bytes to store this message on disk/network
-    type Size: ArrayLength<u8>;
+    type Size: ArrayLength;
 
     /// Serialize this message to a mutable slice. It is enforced at compile time or on the caller
     /// side that this slice is sized to fit this instance. Implementations do not need to check
diff --git a/src/helpers/transport/stream/input.rs b/src/helpers/transport/stream/input.rs
index 2ca6e4a22..9a1b995af 100644
--- a/src/helpers/transport/stream/input.rs
+++ b/src/helpers/transport/stream/input.rs
@@ -14,6 +14,7 @@ use futures::{
     stream::{iter, once, Fuse, FusedStream, Iter, Map, Once},
     Stream, StreamExt,
 };
+use generic_array::GenericArray;
 use pin_project::pin_project;
 use typenum::{Unsigned, U2};
 
@@ -97,7 +98,7 @@ impl BufDeque {
         self.read_bytes(count * T::Size::USIZE).map(|bytes| {
             bytes
                 .chunks(T::Size::USIZE)
-                .map(|bytes| T::deserialize(bytes.into()))
+                .map(|bytes| T::deserialize(GenericArray::from_slice(bytes)))
                 .collect()
         })
     }
@@ -108,7 +109,7 @@ impl BufDeque {
     /// Returns `None` if there is insufficient data available.
     fn read<T: Serializable>(&mut self) -> Option<T> {
         self.read_bytes(T::Size::USIZE)
-            .map(|bytes| T::deserialize(bytes.as_ref().into()))
+            .map(|bytes| T::deserialize(GenericArray::from_slice(&bytes)))
     }
 
     /// Update the buffer with the result of polling a stream.
@@ -517,8 +518,7 @@ mod test {
             let mut stream = RecordsStream::<Fp32BitPrime, _>::from(chunks);
             assert_eq!(stream.buffer.len(), 0);
             for expected_chunk in vec.chunks(<Fp32BitPrime as Serializable>::Size::USIZE) {
-                let expected =
-                    Fp32BitPrime::deserialize(<&GenericArray<u8, _>>::from(expected_chunk));
+                let expected = Fp32BitPrime::deserialize(GenericArray::from_slice(expected_chunk));
                 let n = stream.next().await.unwrap().unwrap();
                 // `RecordsStream` outputs correct value
                 assert_eq!(vec![expected], n);
@@ -704,7 +704,7 @@ mod test {
                                             (data in arb_aligned_bytes(size_in_bytes, max_len), seed in any::<u64>())
             -> (Vec<Fp32BitPrime>, Vec<Vec<u8>>, u64) {
                 let expected = data.chunks(<Fp32BitPrime as Serializable>::Size::USIZE)
-                    .map(|chunk| Fp32BitPrime::deserialize(<&GenericArray<u8, _>>::from(chunk)))
+                    .map(|chunk| Fp32BitPrime::deserialize(<GenericArray<u8, _>>::from_slice(chunk)))
                     .collect();
                 (expected, random_chunks(&data, &mut StdRng::seed_from_u64(seed)), seed)
             }
diff --git a/src/hpke/mod.rs b/src/hpke/mod.rs
index 2e940f05a..5658183bd 100644
--- a/src/hpke/mod.rs
+++ b/src/hpke/mod.rs
@@ -31,12 +31,13 @@ type IpaKdf = hpke::kdf::HkdfSha256;
 
 pub type IpaPublicKey = <IpaKem as hpke::kem::Kem>::PublicKey;
 pub type IpaPrivateKey = <IpaKem as hpke::kem::Kem>::PrivateKey;
+pub type IpaEncappedKey = <IpaKem as hpke::kem::Kem>::EncappedKey;
 
 pub use hpke::{Deserializable, Serializable};
 
 pub trait FieldShareCrypt: GaloisField + IpaSerializable {
-    type EncapKeySize: ArrayLength<u8>;
-    type CiphertextSize: ArrayLength<u8>;
+    type EncapKeySize: ArrayLength;
+    type CiphertextSize: ArrayLength;
     type SemiHonestShares: IpaSerializable + Clone + Debug + Eq;
 }
 
@@ -50,7 +51,7 @@ where
     AdditiveShare<F>: IpaSerializable + Clone + Debug + Eq,
     AeadTag<IpaAead>: Serializable<OutputSize = U16>,
     <AdditiveShare<F> as IpaSerializable>::Size: Add<U16>,
-    <<AdditiveShare<F> as IpaSerializable>::Size as Add<U16>>::Output: ArrayLength<u8>,
+    <<AdditiveShare<F> as IpaSerializable>::Size as Add<U16>>::Output: ArrayLength,
 {
     type EncapKeySize = <<IpaKem as hpke::Kem>::EncappedKey as Serializable>::OutputSize;
     type CiphertextSize = <<AdditiveShare<F> as IpaSerializable>::Size as Add<U16>>::Output;
diff --git a/src/hpke/registry.rs b/src/hpke/registry.rs
index 5a14905e2..338553a8d 100644
--- a/src/hpke/registry.rs
+++ b/src/hpke/registry.rs
@@ -123,12 +123,12 @@ impl PublicKeyRegistry for KeyRegistry<PublicKeyOnly> {
 
 #[cfg(all(test, unit_test))]
 mod tests {
-    use hpke::{kem::EncappedKey, HpkeError, OpModeR, OpModeS};
+    use hpke::{HpkeError, OpModeR, OpModeS};
     use rand::rngs::StdRng;
     use rand_core::{CryptoRng, RngCore, SeedableRng};
 
     use super::*;
-    use crate::hpke::{IpaAead, IpaKdf, IpaKem};
+    use crate::hpke::{IpaAead, IpaEncappedKey, IpaKdf, IpaKem};
 
     const INFO_STR: &[u8] = b"This is an INFO string.";
     const AAD: &[u8] = b"This is AAD.";
@@ -137,7 +137,7 @@ mod tests {
         pk: &IpaPublicKey,
         pt: &[u8],
         r: &mut R,
-    ) -> (EncappedKey, Vec<u8>) {
+    ) -> (IpaEncappedKey, Vec<u8>) {
         let (encapsulated_key, mut encryption_context) =
             hpke::setup_sender::<IpaAead, IpaKdf, IpaKem, _>(&OpModeS::Base, pk, INFO_STR, r)
                 .expect("Can setup the sender.");
@@ -152,7 +152,7 @@ mod tests {
 
     fn decrypt<I: AsRef<[u8]>>(
         sk: &IpaPrivateKey,
-        payload: &(EncappedKey, I),
+        payload: &(IpaEncappedKey, I),
     ) -> Result<Vec<u8>, HpkeError> {
         let (encap_key, ct) = payload;
         let mut decryption_context = hpke::setup_receiver::<IpaAead, IpaKdf, IpaKem>(
diff --git a/src/net/client/mod.rs b/src/net/client/mod.rs
index 725cc63ab..8f9e7b519 100644
--- a/src/net/client/mod.rs
+++ b/src/net/client/mod.rs
@@ -16,10 +16,7 @@ use hyper::{
 };
 use hyper_rustls::{ConfigBuilderExt, HttpsConnector, HttpsConnectorBuilder};
 use pin_project::pin_project;
-use tokio_rustls::{
-    rustls,
-    rustls::{Certificate, PrivateKey, RootCertStore},
-};
+use rustls::{Certificate, PrivateKey, RootCertStore};
 use tracing::error;
 
 use crate::{
diff --git a/src/net/server/mod.rs b/src/net/server/mod.rs
index 8ddd474cb..2e1667c1f 100644
--- a/src/net/server/mod.rs
+++ b/src/net/server/mod.rs
@@ -30,16 +30,13 @@ use futures::{
 };
 use hyper::{header::HeaderName, server::conn::AddrStream, Request};
 use metrics::increment_counter;
+use rustls::{
+    server::AllowAnyAnonymousOrAuthenticatedClient, Certificate, PrivateKey, RootCertStore,
+};
 use rustls_pemfile::Item;
 #[cfg(all(feature = "shuttle", test))]
 use shuttle::future as tokio;
-use tokio_rustls::{
-    rustls::{
-        server::AllowAnyAnonymousOrAuthenticatedClient, Certificate, PrivateKey, RootCertStore,
-        ServerConfig as RustlsServerConfig,
-    },
-    server::TlsStream,
-};
+use tokio_rustls::server::TlsStream;
 use tower::{layer::layer_fn, Service};
 use tower_http::trace::TraceLayer;
 use tracing::{error, Span};
@@ -306,7 +303,7 @@ async fn rustls_config(
     }
     let verifier = AllowAnyAnonymousOrAuthenticatedClient::new(trusted_certs);
 
-    let mut config = RustlsServerConfig::builder()
+    let mut config = rustls::ServerConfig::builder()
         .with_safe_defaults()
         .with_client_cert_verifier(verifier.boxed())
         .with_single_cert(cert, key)?;
@@ -488,12 +485,9 @@ mod e2e_tests {
     use hyper::{client::HttpConnector, http::uri, StatusCode, Version};
     use hyper_rustls::HttpsConnector;
     use metrics_util::debugging::Snapshotter;
-    use tokio_rustls::{
-        rustls,
-        rustls::{
-            client::{ServerCertVerified, ServerCertVerifier},
-            ServerName,
-        },
+    use rustls::{
+        client::{ServerCertVerified, ServerCertVerifier},
+        ServerName,
     };
     use tracing::Level;
 
diff --git a/src/net/test.rs b/src/net/test.rs
index 92b0a2be7..414e808f2 100644
--- a/src/net/test.rs
+++ b/src/net/test.rs
@@ -15,8 +15,8 @@ use std::{
 };
 
 use once_cell::sync::Lazy;
+use rustls::Certificate;
 use tokio::task::JoinHandle;
-use tokio_rustls::rustls::Certificate;
 
 use crate::{
     config::{
diff --git a/src/protocol/aggregation/input.rs b/src/protocol/aggregation/input.rs
index 7f8c6ee70..426ed0f99 100644
--- a/src/protocol/aggregation/input.rs
+++ b/src/protocol/aggregation/input.rs
@@ -21,7 +21,7 @@ where
     Replicated<BK>: Serializable,
     <Replicated<CV> as Serializable>::Size: Add<<Replicated<BK> as Serializable>::Size>,
     <<Replicated<CV> as Serializable>::Size as Add<<Replicated<BK> as Serializable>::Size>>::Output:
-        ArrayLength<u8>,
+        ArrayLength,
 {
     type Size = <<Replicated<CV> as Serializable>::Size as Add<
         <Replicated<BK> as Serializable>::Size,
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index eca798743..b8f516684 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -104,7 +104,7 @@ where
                 >>::Output,
             >>::Output,
         >>::Output,
-    >>::Output: ArrayLength<u8>,
+    >>::Output: ArrayLength,
 {
     type Size = <<Replicated<F> as Serializable>::Size as Add<
         <<Replicated<MK> as Serializable>::Size as Add<
diff --git a/src/protocol/prss/crypto.rs b/src/protocol/prss/crypto.rs
index e3eb415b7..a2fa2d558 100644
--- a/src/protocol/prss/crypto.rs
+++ b/src/protocol/prss/crypto.rs
@@ -101,7 +101,7 @@ pub struct KeyExchange {
 impl KeyExchange {
     pub fn new<R: RngCore + CryptoRng>(r: &mut R) -> Self {
         Self {
-            sk: EphemeralSecret::new(r),
+            sk: EphemeralSecret::random_from_rng(r),
         }
     }
 
diff --git a/src/report.rs b/src/report.rs
index 88d26d995..094a31997 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -256,7 +256,7 @@ where
         .unwrap(); // validated on construction
 
         let mut ciphertext: GenericArray<u8, <Gf40Bit as FieldShareCrypt>::CiphertextSize> =
-            GenericArray::clone_from_slice(self.match_key_ciphertext());
+            *GenericArray::from_slice(self.match_key_ciphertext());
         let plaintext = open_in_place(key_registry, self.encap_key(), &mut ciphertext, &info)?;
 
         Ok(Report {
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index 908a45feb..f366c870c 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -45,7 +45,7 @@ impl<T, Rhs, Output> Arithmetic<Rhs, Output> for T where
 // Trait for primitive integer types used to represent the underlying type for shared values
 pub trait Block: Sized + Copy + Debug {
     /// Size of a block in bytes big enough to hold the shared value. `Size * 8 >= VALID_BIT_LENGTH`.
-    type Size: ArrayLength<u8>;
+    type Size: ArrayLength;
 }
 
 pub trait SharedValue:
diff --git a/src/secret_sharing/replicated/malicious/additive_share.rs b/src/secret_sharing/replicated/malicious/additive_share.rs
index 025590193..c2fe440c4 100644
--- a/src/secret_sharing/replicated/malicious/additive_share.rs
+++ b/src/secret_sharing/replicated/malicious/additive_share.rs
@@ -294,7 +294,7 @@ where
         Add<<SemiHonestAdditiveShare<V::ExtendedField> as Serializable>::Size>,
     <<SemiHonestAdditiveShare<V> as Serializable>::Size as Add<
         <SemiHonestAdditiveShare<V::ExtendedField> as Serializable>::Size,
-    >>::Output: ArrayLength<u8>,
+    >>::Output: ArrayLength,
 {
     type Size = <<SemiHonestAdditiveShare<V> as Serializable>::Size as Add<
         <SemiHonestAdditiveShare<V::ExtendedField> as Serializable>::Size,
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index cc48cf78b..10b8b2b39 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -220,7 +220,7 @@ impl<V: SharedValue> From<(V, V)> for AdditiveShare<V> {
 impl<V: SharedValue> Serializable for AdditiveShare<V>
 where
     V::Size: Add<V::Size>,
-    <V::Size as Add<V::Size>>::Output: ArrayLength<u8>,
+    <V::Size as Add<V::Size>>::Output: ArrayLength,
 {
     type Size = <V::Size as Add<V::Size>>::Output;
 

From 53d71f20b9aca3a850a6f506559deb04f748c692 Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Mon, 23 Oct 2023 16:05:30 +0800
Subject: [PATCH 058/105] remove did_trigger_get_attributed and refactor
 attribution flag calculations

---
 src/protocol/prf_sharding/mod.rs | 56 +++++++++++++++-----------------
 1 file changed, 26 insertions(+), 30 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index aec7bee85..74505c09a 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -97,7 +97,6 @@ impl InputsRequiredFromPrevRow {
     ///         - `did_trigger_get_attributed` - a secret-shared bit indicating if this row corresponds to a trigger event
     ///           which was attributed. Might be able to reveal this (after a shuffle and the addition of dummies) to minimize
     ///           the amount of processing work that must be done in the Aggregation stage.
-    #[allow(clippy::too_many_lines)]
     pub async fn compute_row_with_previous<C, BK, TV, TS>(
         &mut self,
         ctx: C,
@@ -152,29 +151,15 @@ impl InputsRequiredFromPrevRow {
         )
         .await?;
 
-        let (did_trigger_get_attributed, is_trigger_within_window) = try_join(
-            input_row.is_trigger_bit.multiply(
-                &ever_encountered_a_source_event,
-                ctx.narrow(&Step::DidTriggerGetAttributed),
-                record_id,
-            ),
-            is_trigger_event_within_attribution_window(
-                ctx.narrow(&Step::CheckAttributionWindow),
-                record_id,
-                attribution_window_seconds,
-                &timestamp,
-                &source_event_timestamp,
-            ),
-        )
-        .await?;
-
         let attributed_trigger_value = zero_out_trigger_value_unless_attributed(
             ctx.narrow(&Step::AttributedTriggerValue),
             record_id,
-            &did_trigger_get_attributed,
-            &is_trigger_within_window,
+            &input_row.is_trigger_bit,
+            &ever_encountered_a_source_event,
             &tv,
             attribution_window_seconds,
+            &timestamp,
+            &source_event_timestamp,
         )
         .await?;
 
@@ -218,7 +203,6 @@ impl InputsRequiredFromPrevRow {
         self.source_event_timestamp = source_event_timestamp;
 
         let outputs_for_aggregation = CappedAttributionOutputs {
-            did_trigger_get_attributed,
             attributed_breakdown_key_bits,
             capped_attributed_trigger_value,
         };
@@ -228,7 +212,6 @@ impl InputsRequiredFromPrevRow {
 
 #[derive(Debug)]
 pub struct CappedAttributionOutputs {
-    pub did_trigger_get_attributed: Replicated<Gf2>,
     pub attributed_breakdown_key_bits: BitDecomposed<Replicated<Gf2>>,
     pub capped_attributed_trigger_value: BitDecomposed<Replicated<Gf2>>,
 }
@@ -557,22 +540,41 @@ where
 /// another secret-shared bit indicating if a given row is within the attribution window. We multiply these two bits together and
 /// multiply it with the bits of the `trigger_value` in order to zero out contributions from unattributed trigger events.
 ///
+#[allow(clippy::too_many_arguments)]
 async fn zero_out_trigger_value_unless_attributed<C>(
     ctx: C,
     record_id: RecordId,
-    did_trigger_get_attributed: &Replicated<Gf2>,
-    is_trigger_within_window: &Replicated<Gf2>,
+    is_trigger_bit: &Replicated<Gf2>,
+    ever_encountered_a_source_event: &Replicated<Gf2>,
     trigger_value: &BitDecomposed<Replicated<Gf2>>,
     attribution_window_seconds: Option<NonZeroU32>,
+    trigger_event_timestamp: &BitDecomposed<Replicated<Gf2>>,
+    source_event_timestamp: &BitDecomposed<Replicated<Gf2>>,
 ) -> Result<BitDecomposed<Replicated<Gf2>>, Error>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
 {
+    let (did_trigger_get_attributed, is_trigger_within_window) = try_join(
+        is_trigger_bit.multiply(
+            ever_encountered_a_source_event,
+            ctx.narrow(&Step::DidTriggerGetAttributed),
+            record_id,
+        ),
+        is_trigger_event_within_attribution_window(
+            ctx.narrow(&Step::CheckAttributionWindow),
+            record_id,
+            attribution_window_seconds,
+            trigger_event_timestamp,
+            source_event_timestamp,
+        ),
+    )
+    .await?;
+
     // save 1 multiplication if there is no attribution window
     let zero_out_flag = if attribution_window_seconds.is_some() {
         let c = ctx.narrow(&Step::AttributedEventCheckFlag);
         did_trigger_get_attributed
-            .multiply(is_trigger_within_window, c, record_id)
+            .multiply(&is_trigger_within_window, c, record_id)
             .await?
     } else {
         did_trigger_get_attributed.clone()
@@ -983,27 +985,21 @@ pub mod tests {
                 capped_attributed_trigger_value,
             } = self;
 
-            let did_trigger_get_attributed = Gf2::ONE;
             let [attributed_breakdown_key0, attributed_breakdown_key1, attributed_breakdown_key2] =
                 attributed_breakdown_key.share_with(rng);
             let [capped_attributed_trigger_value0, capped_attributed_trigger_value1, capped_attributed_trigger_value2] =
                 capped_attributed_trigger_value.share_with(rng);
-            let [did_trigger_get_attributed0, did_trigger_get_attributed1, did_trigger_get_attributed2] =
-                did_trigger_get_attributed.share_with(rng);
 
             [
                 CappedAttributionOutputs {
-                    did_trigger_get_attributed: did_trigger_get_attributed0,
                     attributed_breakdown_key_bits: attributed_breakdown_key0,
                     capped_attributed_trigger_value: capped_attributed_trigger_value0,
                 },
                 CappedAttributionOutputs {
-                    did_trigger_get_attributed: did_trigger_get_attributed1,
                     attributed_breakdown_key_bits: attributed_breakdown_key1,
                     capped_attributed_trigger_value: capped_attributed_trigger_value1,
                 },
                 CappedAttributionOutputs {
-                    did_trigger_get_attributed: did_trigger_get_attributed2,
                     attributed_breakdown_key_bits: attributed_breakdown_key2,
                     capped_attributed_trigger_value: capped_attributed_trigger_value2,
                 },

From 1ce428103ef31f072071e1bd7330e28f084724fe Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 24 Oct 2023 10:49:21 +0800
Subject: [PATCH 059/105] 1. Increasing max number of breakdowns we can support
 with OPRF 2. In case no conversion is attributed to any bucket,
 do_aggregation would return vector with zeroes

---
 src/protocol/prf_sharding/bucket.rs | 38 +++++++++++++++++++++--------
 src/protocol/prf_sharding/mod.rs    |  7 ++++++
 2 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/src/protocol/prf_sharding/bucket.rs b/src/protocol/prf_sharding/bucket.rs
index 6349f91a6..d199557bd 100644
--- a/src/protocol/prf_sharding/bucket.rs
+++ b/src/protocol/prf_sharding/bucket.rs
@@ -1,17 +1,35 @@
 use embed_doc_image::embed_doc_image;
+use ipa_macros::Step;
 
 use crate::{
     error::Error,
     ff::{GaloisField, PrimeField, Serializable},
     protocol::{
-        basics::SecureMul, context::UpgradedContext, prf_sharding::BinaryTreeDepthStep,
-        step::BitOpStep, RecordId,
+        basics::SecureMul, context::UpgradedContext, prf_sharding::BinaryTreeDepthStep, RecordId,
     },
     secret_sharing::{
         replicated::malicious::ExtendableField, BitDecomposed, Linear as LinearSecretSharing,
     },
 };
 
+#[derive(Step)]
+pub enum BucketStep {
+    #[dynamic(256)]
+    Bit(usize),
+}
+
+impl From<u32> for BucketStep {
+    fn from(v: u32) -> Self {
+        Self::Bit(usize::try_from(v).unwrap())
+    }
+}
+
+impl From<usize> for BucketStep {
+    fn from(v: usize) -> Self {
+        Self::Bit(v)
+    }
+}
+
 #[embed_doc_image("tree-aggregation", "images/tree_aggregation.png")]
 /// This function moves a single value to a correct bucket using tree aggregation approach
 ///
@@ -53,8 +71,8 @@ where
         BK::BITS
     );
     assert!(
-        breakdown_count <= 128,
-        "Our step implementation (BitOpStep) cannot go past 64"
+        breakdown_count <= 512,
+        "Our step implementation (BucketStep) cannot go past 256"
     );
     let mut row_contribution = vec![value; breakdown_count];
 
@@ -69,7 +87,7 @@ where
         let mut futures = Vec::with_capacity(breakdown_count / step);
 
         for (i, tree_index) in (0..breakdown_count).step_by(step).enumerate() {
-            let bit_c = depth_c.narrow(&BitOpStep::from(i));
+            let bit_c = depth_c.narrow(&BucketStep::from(i));
 
             if robust || tree_index + span < breakdown_count {
                 futures.push(row_contribution[tree_index].multiply(bit_of_bdkey, bit_c, record_id));
@@ -96,7 +114,7 @@ pub mod tests {
     use rand::thread_rng;
 
     use crate::{
-        ff::{Field, Fp32BitPrime, Gf5Bit, Gf8Bit},
+        ff::{Field, Fp32BitPrime, Gf8Bit},
         protocol::{
             context::{Context, UpgradableContext, Validator},
             prf_sharding::bucket::move_single_value_to_bucket,
@@ -108,12 +126,12 @@ pub mod tests {
         test_fixture::{get_bits, Reconstruct, Runner, TestWorld},
     };
 
-    const MAX_BREAKDOWN_COUNT: usize = 1 << Gf5Bit::BITS;
+    const MAX_BREAKDOWN_COUNT: usize = 256;
     const VALUE: u32 = 10;
 
     async fn move_to_bucket(count: usize, breakdown_key: usize, robust: bool) -> Vec<Fp32BitPrime> {
         let breakdown_key_bits =
-            get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf5Bit::BITS);
+            get_bits::<Fp32BitPrime>(breakdown_key.try_into().unwrap(), Gf8Bit::BITS);
         let value = Fp32BitPrime::truncate_from(VALUE);
 
         TestWorld::default()
@@ -122,7 +140,7 @@ pub mod tests {
                 |ctx, (breakdown_key_share, value_share)| async move {
                     let validator = ctx.validator();
                     let ctx = validator.context();
-                    move_single_value_to_bucket::<Gf5Bit, _, _, Fp32BitPrime>(
+                    move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
                         ctx.set_total_records(1),
                         RecordId::from(0),
                         breakdown_key_share,
@@ -221,7 +239,7 @@ pub mod tests {
                             RecordId::from(0),
                             breakdown_key_share,
                             value_share,
-                            129,
+                            513,
                             false,
                         )
                         .await
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 110dc452a..4412d0e0a 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -592,6 +592,13 @@ where
     F: PrimeField + ExtendableField,
 {
     let num_records = user_level_attributions.len();
+
+    // in case no attributable conversion is found, return 0.
+    // as anyways the helpers know that no attributions resulted.
+    if num_records == 0 {
+        return Ok(vec![S::ZERO; 1 << BK::BITS]);
+    }
+
     let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
         .into_iter()
         .map(|row| {

From 034f556e578790ce0def32d04bc2b05179d0a3eb Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 24 Oct 2023 13:49:02 +0800
Subject: [PATCH 060/105] Adding a oneshot for oprf

It fails if user cap is small which we are investigating. However, this PR can still be reviewed and checked in

Sample command to run
cargo bench --bench oneshot_ipa --features="enable-benches descriptive-gate" --no-default-features -- --per-user-cap 64 --oprf --max-trigger-value 4 -n 100
---
 benches/oneshot/ipa.rs            | 24 +++++----
 pre-commit                        |  2 +-
 src/ff/galois_field.rs            | 17 ++++++-
 src/ff/mod.rs                     |  2 +-
 src/protocol/mod.rs               |  4 +-
 src/protocol/prf_sharding/mod.rs  |  8 +--
 src/report.rs                     | 14 +++++
 src/test_fixture/input/sharing.rs | 32 +++++++++++-
 src/test_fixture/ipa.rs           | 85 ++++++++++++++++++++++++++++++-
 9 files changed, 168 insertions(+), 20 deletions(-)

diff --git a/benches/oneshot/ipa.rs b/benches/oneshot/ipa.rs
index a7102f91b..ab6e723e2 100644
--- a/benches/oneshot/ipa.rs
+++ b/benches/oneshot/ipa.rs
@@ -9,7 +9,7 @@ use ipa::{
     ff::Fp32BitPrime,
     helpers::{query::IpaQueryConfig, GatewayConfig},
     test_fixture::{
-        ipa::{ipa_in_the_clear, test_ipa, IpaSecurityModel},
+        ipa::{ipa_in_the_clear, test_ipa, test_oprf_ipa, IpaSecurityModel},
         EventGenerator, EventGeneratorConfig, TestWorld, TestWorldConfig,
     },
 };
@@ -70,6 +70,8 @@ struct Args {
     /// Needed for benches.
     #[arg(long, hide = true)]
     bench: bool,
+    #[arg(short = 'o', long)]
+    oprf: bool,
 }
 
 impl Args {
@@ -132,14 +134,18 @@ async fn run(args: Args) -> Result<(), Error> {
     tracing::trace!("Preparation complete in {:?}", _prep_time.elapsed());
 
     let _protocol_time = Instant::now();
-    test_ipa::<BenchField>(
-        &world,
-        &raw_data,
-        &expected_results,
-        args.config(),
-        args.mode,
-    )
-    .await;
+    if args.oprf {
+        test_oprf_ipa::<BenchField>(&world, raw_data, &expected_results, args.config()).await;
+    } else {
+        test_ipa::<BenchField>(
+            &world,
+            &raw_data,
+            &expected_results,
+            args.config(),
+            args.mode,
+        )
+        .await;
+    }
     tracing::trace!(
         "{m:?} IPA for {q} records took {t:?}",
         m = args.mode,
diff --git a/pre-commit b/pre-commit
index 12d63958b..6cf2be072 100755
--- a/pre-commit
+++ b/pre-commit
@@ -103,4 +103,4 @@ check "Arithmetic circuit benchmark" \
     cargo bench --bench oneshot_arithmetic --no-default-features --features "enable-benches descriptive-gate"
 
 check "Sort benchmark" \
-    cargo bench --bench oneshot_sort --no-default-features --features="enable-benches descriptive-gate"
+    cargo bench --bench oneshot_sort --no-default-features --features="enable-benches descriptive-gate"
\ No newline at end of file
diff --git a/src/ff/galois_field.rs b/src/ff/galois_field.rs
index 18b6b58c8..cca6f3936 100644
--- a/src/ff/galois_field.rs
+++ b/src/ff/galois_field.rs
@@ -5,7 +5,7 @@ use std::{
 
 use bitvec::prelude::{bitarr, BitArr, Lsb0};
 use generic_array::GenericArray;
-use typenum::{Unsigned, U1, U4, U5};
+use typenum::{Unsigned, U1, U3, U4, U5};
 
 use crate::{
     ff::{Field, Serializable},
@@ -25,6 +25,7 @@ pub trait GaloisField:
 
 // Bit store type definitions
 type U8_1 = BitArr!(for 8, in u8, Lsb0);
+type U8_3 = BitArr!(for 24, in u8, Lsb0);
 type U8_4 = BitArr!(for 32, in u8, Lsb0);
 type U8_5 = BitArr!(for 40, in u8, Lsb0);
 
@@ -32,6 +33,10 @@ impl Block for U8_1 {
     type Size = U1;
 }
 
+impl Block for U8_3 {
+    type Size = U3;
+}
+
 impl Block for U8_4 {
     type Size = U4;
 }
@@ -550,6 +555,16 @@ bit_array_impl!(
     0b1_0000_0000_0000_0000_0000_0000_1000_1101_u128
 );
 
+bit_array_impl!(
+    bit_array_20,
+    Gf20Bit,
+    U8_3,
+    20,
+    bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+    // x^20 + x^17 + x^15 + x^14 + x^11 + x^10 + x^9 + x^7 + x^6 + x^5 + 1
+    0b1_0010_1100_1110_1110_0001_u128
+);
+
 bit_array_impl!(
     bit_array_8,
     Gf8Bit,
diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 5544f2378..e324a4a72 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -9,7 +9,7 @@ mod prime_field;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 
 pub use field::{Field, FieldType};
-pub use galois_field::{GaloisField, Gf2, Gf32Bit, Gf3Bit, Gf40Bit, Gf5Bit, Gf8Bit};
+pub use galois_field::{GaloisField, Gf2, Gf20Bit, Gf32Bit, Gf3Bit, Gf40Bit, Gf5Bit, Gf8Bit};
 use generic_array::{ArrayLength, GenericArray};
 #[cfg(any(test, feature = "weak-field"))]
 pub use prime_field::Fp31;
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index 7931a1e37..03270a1e1 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -22,11 +22,13 @@ pub use basics::BasicProtocols;
 
 use crate::{
     error::Error,
-    ff::{Gf40Bit, Gf8Bit},
+    ff::{Gf20Bit, Gf3Bit, Gf40Bit, Gf8Bit},
 };
 
 pub type MatchKey = Gf40Bit;
 pub type BreakdownKey = Gf8Bit;
+pub type TriggerValue = Gf3Bit;
+pub type Timestamp = Gf20Bit;
 
 /// Unique identifier of the MPC query requested by report collectors
 /// TODO(615): Generating this unique id may be tricky as it may involve communication between helpers and
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 4412d0e0a..b6d334ee0 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -30,10 +30,10 @@ pub mod bucket;
 pub mod feature_label_dot_product;
 
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {
-    prf_of_match_key: u64,
-    is_trigger_bit: Replicated<Gf2>,
-    breakdown_key: Replicated<BK>,
-    trigger_value: Replicated<TV>,
+    pub prf_of_match_key: u64,
+    pub is_trigger_bit: Replicated<Gf2>,
+    pub breakdown_key: Replicated<BK>,
+    pub trigger_value: Replicated<TV>,
 }
 
 struct InputsRequiredFromPrevRow {
diff --git a/src/report.rs b/src/report.rs
index 094a31997..2b9cf1039 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -386,6 +386,20 @@ where
     }
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct OprfReport<TS, BK, TV>
+where
+    TS: GaloisField,
+    BK: GaloisField,
+    TV: GaloisField,
+{
+    pub timestamp: Replicated<TS>,
+    pub mk_oprf: u64,
+    pub event_type: EventType,
+    pub breakdown_key: Replicated<BK>,
+    pub trigger_value: Replicated<TV>,
+}
+
 #[cfg(all(test, unit_test))]
 mod test {
     use rand::{distributions::Alphanumeric, rngs::StdRng, Rng};
diff --git a/src/test_fixture/input/sharing.rs b/src/test_fixture/input/sharing.rs
index f21dc4920..1287ad8e0 100644
--- a/src/test_fixture/input/sharing.rs
+++ b/src/test_fixture/input/sharing.rs
@@ -12,7 +12,7 @@ use crate::{
         BreakdownKey, MatchKey,
     },
     rand::Rng,
-    report::{EventType, Report},
+    report::{EventType, OprfReport, Report},
     secret_sharing::{replicated::semi_honest::AdditiveShare as Replicated, IntoShares},
     test_fixture::{
         input::{GenericReportShare, GenericReportTestInput},
@@ -354,3 +354,33 @@ where
         }
     }
 }
+
+impl<TS, BK, TV> IntoShares<OprfReport<TS, BK, TV>> for TestRawDataRecord
+where
+    TS: GaloisField + IntoShares<Replicated<TS>>,
+    BK: GaloisField + IntoShares<Replicated<BK>>,
+    TV: GaloisField + IntoShares<Replicated<TV>>,
+{
+    fn share_with<R: Rng>(self, rng: &mut R) -> [OprfReport<TS, BK, TV>; 3] {
+        let event_type = if self.is_trigger_report {
+            EventType::Trigger
+        } else {
+            EventType::Source
+        };
+        let timestamp = TS::truncate_from(self.timestamp).share_with(rng);
+        let breakdown_key = BK::truncate_from(self.breakdown_key).share_with(rng);
+        let trigger_value = TV::truncate_from(self.trigger_value).share_with(rng);
+
+        zip(zip(timestamp, breakdown_key), trigger_value)
+            .map(|((ts_share, bk_share), tv_share)| OprfReport {
+                timestamp: ts_share,
+                mk_oprf: self.user_id,
+                event_type,
+                breakdown_key: bk_share,
+                trigger_value: tv_share,
+            })
+            .collect::<Vec<_>>()
+            .try_into()
+            .unwrap()
+    }
+}
diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index 37e31b535..d279806c2 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -5,9 +5,13 @@ use crate::{
     ff::{PrimeField, Serializable},
     helpers::query::IpaQueryConfig,
     ipa_test_input,
-    protocol::{ipa::ipa, BreakdownKey, MatchKey},
+    protocol::{ipa::ipa, BreakdownKey, MatchKey, Timestamp, TriggerValue},
+    report::OprfReport,
     secret_sharing::{
-        replicated::{malicious, malicious::ExtendableField, semi_honest},
+        replicated::{
+            malicious, malicious::ExtendableField, semi_honest,
+            semi_honest::AdditiveShare as Replicated,
+        },
         IntoShares,
     },
     test_fixture::{input::GenericReportTestInput, Reconstruct},
@@ -191,3 +195,80 @@ pub async fn test_ipa<F>(
         .collect::<Vec<_>>();
     assert_eq!(result, expected_results);
 }
+
+/// # Panics
+/// If any of the IPA protocol modules panic
+#[cfg(feature = "in-memory-infra")]
+pub async fn test_oprf_ipa<F>(
+    world: &super::TestWorld,
+    mut records: Vec<TestRawDataRecord>,
+    expected_results: &[u32],
+    config: IpaQueryConfig,
+) where
+    F: PrimeField + ExtendableField + IntoShares<semi_honest::AdditiveShare<F>>,
+    rand::distributions::Standard: rand::distributions::Distribution<F>,
+    semi_honest::AdditiveShare<F>: Serializable,
+{
+    use crate::{
+        ff::{Field, Gf2},
+        protocol::{
+            basics::ShareKnownValue,
+            prf_sharding::{attribution_and_capping_and_aggregation, PrfShardedIpaInputRow},
+        },
+        report::EventType,
+        secret_sharing::SharedValue,
+        test_fixture::Runner,
+    };
+
+    let user_cap: i32 = config.per_user_credit_cap.try_into().unwrap();
+    assert!(
+        user_cap & (user_cap - 1) == 0,
+        "This code only works for a user cap which is a power of 2"
+    );
+
+    //TODO(richaj) This manual sorting will be removed once we have the PRF sharding in place
+    records.sort_by(|a, b| b.user_id.cmp(&a.user_id));
+
+    let result: Vec<F> = world
+        .semi_honest(
+            records.into_iter(),
+            |ctx, input_rows: Vec<OprfReport<Timestamp, BreakdownKey, TriggerValue>>| async move {
+                let sharded_input = input_rows
+                    .into_iter()
+                    .map(|single_row| {
+                        let is_trigger_bit_share = if single_row.event_type == EventType::Trigger {
+                            Replicated::share_known_value(&ctx, Gf2::ONE)
+                        } else {
+                            Replicated::share_known_value(&ctx, Gf2::ZERO)
+                        };
+                        PrfShardedIpaInputRow {
+                            prf_of_match_key: single_row.mk_oprf,
+                            is_trigger_bit: is_trigger_bit_share,
+                            breakdown_key: single_row.breakdown_key,
+                            trigger_value: single_row.trigger_value,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                attribution_and_capping_and_aggregation::<
+                    _,
+                    BreakdownKey,
+                    TriggerValue,
+                    F,
+                    _,
+                    Replicated<Gf2>,
+                >(ctx, sharded_input, user_cap.ilog2().try_into().unwrap())
+                .await
+                .unwrap()
+            },
+        )
+        .await
+        .reconstruct();
+
+    let mut result = result
+        .into_iter()
+        .map(|v| u32::try_from(v.as_u128()).unwrap())
+        .collect::<Vec<_>>();
+    let _ = result.split_off(expected_results.len());
+    assert_eq!(result, expected_results);
+}

From 2692af8241a7b5ec13e120286a6fc91ad2167f0f Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 24 Oct 2023 15:28:13 +0800
Subject: [PATCH 061/105] Now oprf can run for compact-gate as well

---
 scripts/collect_steps.py         |   2 +-
 src/protocol/mod.rs              |   1 -
 src/protocol/prf_sharding/mod.rs |   1 -
 src/protocol/step/steps.txt      | 427 +++++++++++++++++++++++++++++++
 4 files changed, 428 insertions(+), 3 deletions(-)

diff --git a/scripts/collect_steps.py b/scripts/collect_steps.py
index 3768fbe07..105cab428 100755
--- a/scripts/collect_steps.py
+++ b/scripts/collect_steps.py
@@ -175,4 +175,4 @@ def extract_intermediate_steps(steps):
     sorted_steps = sorted(full_steps)
 
     for step in sorted_steps:
-        print(step)
+        print(step)
\ No newline at end of file
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index 03270a1e1..cc0ae5ab8 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -6,7 +6,6 @@ pub mod context;
 pub mod dp;
 pub mod ipa;
 pub mod modulus_conversion;
-#[cfg(feature = "descriptive-gate")]
 pub mod prf_sharding;
 pub mod prss;
 pub mod sort;
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index b6d334ee0..7feb01f9a 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -26,7 +26,6 @@ use crate::{
 };
 
 pub mod bucket;
-#[cfg(feature = "descriptive-gate")]
 pub mod feature_label_dot_product;
 
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {
diff --git a/src/protocol/step/steps.txt b/src/protocol/step/steps.txt
index d2bc41200..fc5726835 100644
--- a/src/protocol/step/steps.txt
+++ b/src/protocol/step/steps.txt
@@ -8812,3 +8812,430 @@ ipa::protocol::ipa::Step::gen_sort_permutation_from_match_keys/ipa::protocol::so
 ipa::protocol::ipa::Step::gen_sort_permutation_from_match_keys/ipa::protocol::sort::SortStep::sort_keys/ipa::protocol::step::IpaProtocolStep::sort9/ipa::protocol::sort::SortStep::shuffle_reveal_permutation/ipa::protocol::sort::ShuffleRevealPermutationStep::shuffle/ipa::protocol::sort::ShuffleStep::shuffle1
 ipa::protocol::ipa::Step::gen_sort_permutation_from_match_keys/ipa::protocol::sort::SortStep::sort_keys/ipa::protocol::step::IpaProtocolStep::sort9/ipa::protocol::sort::SortStep::shuffle_reveal_permutation/ipa::protocol::sort::ShuffleRevealPermutationStep::shuffle/ipa::protocol::sort::ShuffleStep::shuffle2
 ipa::protocol::ipa::Step::gen_sort_permutation_from_match_keys/ipa::protocol::sort::SortStep::sort_keys/ipa::protocol::step::IpaProtocolStep::sort9/ipa::protocol::sort::SortStep::shuffle_reveal_permutation/ipa::protocol::sort::ShuffleRevealPermutationStep::shuffle/ipa::protocol::sort::ShuffleStep::shuffle3
+ipa::protocol::prf_sharding::Step::binary_validator
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit100
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit101
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit102
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit103
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit104
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit105
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit106
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit107
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit108
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit109
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit110
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit111
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit112
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit113
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit114
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit115
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit116
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit117
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit118
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit119
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit120
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit121
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit122
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit123
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit124
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit125
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit126
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit127
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit32
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit33
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit34
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit35
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit36
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit37
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit38
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit39
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit40
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit41
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit42
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit43
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit44
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit45
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit46
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit47
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit48
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit49
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit50
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit51
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit52
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit53
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit54
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit55
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit56
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit57
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit58
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit59
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit60
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit61
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit62
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit63
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit64
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit65
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit66
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit67
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit68
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit69
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit70
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit71
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit72
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit73
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit74
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit75
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit76
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit77
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit78
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit79
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit80
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit81
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit82
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit83
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit84
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit85
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit86
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit87
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit88
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit89
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit90
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit91
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit92
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit93
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit94
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit95
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit96
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit97
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit98
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit99
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit32
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit33
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit34
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit35
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit36
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit37
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit38
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit39
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit40
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit41
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit42
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit43
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit44
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit45
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit46
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit47
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit48
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit49
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit50
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit51
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit52
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit53
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit54
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit55
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit56
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit57
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit58
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit59
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit60
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit61
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit62
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit63
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth7/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated

From 2a798a3c90a97bad639fcd9714e509d4a4fc9783 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 24 Oct 2023 15:56:11 +0800
Subject: [PATCH 062/105] Adding oprf handling in collect_steps.py

---
 scripts/collect_steps.py         | 26 ++++++++++++++++++++++++++
 src/protocol/prf_sharding/mod.rs |  1 +
 src/protocol/step/steps.txt      |  6 ++++++
 3 files changed, 33 insertions(+)

diff --git a/scripts/collect_steps.py b/scripts/collect_steps.py
index 105cab428..bf47eefbe 100755
--- a/scripts/collect_steps.py
+++ b/scripts/collect_steps.py
@@ -31,6 +31,9 @@
 SECURITY_MODEL = ["malicious", "semi-honest"]
 ROOT_STEP_PREFIX = "protocol/alloc::string::String::run-0"
 
+OPRF_USER_CAP = [16, 64, 128]
+OPRF_SECURITY_MODEL = ["semi-honest"]
+OPRF_TRIGGER_VALUE = [4]
 # TODO(taikiy): #771 allows us to remove this synthetic step generation code
 
 # There are protocols in IPA that that will generate log(N) steps where N is the number
@@ -171,6 +174,29 @@ def extract_intermediate_steps(steps):
                     print(" ".join(args), file=sys.stderr)
                     steps.update(collect_steps(args))
 
+    for c in OPRF_USER_CAP:
+        for w in ATTRIBUTION_WINDOW:
+            for b in BREAKDOWN_KEYS:
+                for m in OPRF_SECURITY_MODEL:
+                    for tv in OPRF_TRIGGER_VALUE:
+                        args = ARGS + [
+                            "-n",
+                            str(QUERY_SIZE),
+                            "-c",
+                            str(c),
+                            "-w",
+                            str(w),
+                            "-b",
+                            str(b),
+                            "-m",
+                            m,
+                            "-t",
+                            str(tv),
+                            "-o"
+                        ]
+                    print(" ".join(args), file=sys.stderr)
+                    steps.update(collect_steps(args))
+
     full_steps = extract_intermediate_steps(steps)
     sorted_steps = sorted(full_steps)
 
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 7feb01f9a..b6d334ee0 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -26,6 +26,7 @@ use crate::{
 };
 
 pub mod bucket;
+#[cfg(feature = "descriptive-gate")]
 pub mod feature_label_dot_product;
 
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField> {
diff --git a/src/protocol/step/steps.txt b/src/protocol/step/steps.txt
index fc5726835..042e01c6f 100644
--- a/src/protocol/step/steps.txt
+++ b/src/protocol/step/steps.txt
@@ -9193,6 +9193,9 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
@@ -9228,6 +9231,9 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1

From 8fa67457b91296d4263d780a691f30af91c55942 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 24 Oct 2023 16:08:17 +0800
Subject: [PATCH 063/105] refactoring collect_steps

---
 scripts/collect_steps.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/scripts/collect_steps.py b/scripts/collect_steps.py
index bf47eefbe..9664a1c06 100755
--- a/scripts/collect_steps.py
+++ b/scripts/collect_steps.py
@@ -31,9 +31,6 @@
 SECURITY_MODEL = ["malicious", "semi-honest"]
 ROOT_STEP_PREFIX = "protocol/alloc::string::String::run-0"
 
-OPRF_USER_CAP = [16, 64, 128]
-OPRF_SECURITY_MODEL = ["semi-honest"]
-OPRF_TRIGGER_VALUE = [4]
 # TODO(taikiy): #771 allows us to remove this synthetic step generation code
 
 # There are protocols in IPA that that will generate log(N) steps where N is the number
@@ -152,9 +149,7 @@ def extract_intermediate_steps(steps):
 
     return steps
 
-
-if __name__ == "__main__":
-    steps = set()
+def ipa_steps(steps):
     for c in PER_USER_CAP:
         for w in ATTRIBUTION_WINDOW:
             for b in BREAKDOWN_KEYS:
@@ -174,6 +169,11 @@ def extract_intermediate_steps(steps):
                     print(" ".join(args), file=sys.stderr)
                     steps.update(collect_steps(args))
 
+OPRF_USER_CAP = [16, 64, 128]
+OPRF_SECURITY_MODEL = ["semi-honest"]
+OPRF_TRIGGER_VALUE = [4]
+
+def oprf_steps(steps):
     for c in OPRF_USER_CAP:
         for w in ATTRIBUTION_WINDOW:
             for b in BREAKDOWN_KEYS:
@@ -197,6 +197,11 @@ def extract_intermediate_steps(steps):
                     print(" ".join(args), file=sys.stderr)
                     steps.update(collect_steps(args))
 
+if __name__ == "__main__":
+    steps = set()
+    ipa_steps(steps)
+    oprf_steps(steps)
+
     full_steps = extract_intermediate_steps(steps)
     sorted_steps = sorted(full_steps)
 

From d9d9672e9c645fa4c4569d8dd9a5c1613747fd22 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 24 Oct 2023 16:58:43 +0800
Subject: [PATCH 064/105] Add test for no contribution + handle 512 breakdowns
 in test using Gf9Bit

---
 src/ff/galois_field.rs              | 17 ++++++++++++++++-
 src/ff/mod.rs                       |  2 +-
 src/protocol/prf_sharding/bucket.rs | 19 +++++++++++++------
 src/protocol/prf_sharding/mod.rs    | 23 +++++++++++++++++++++++
 4 files changed, 53 insertions(+), 8 deletions(-)

diff --git a/src/ff/galois_field.rs b/src/ff/galois_field.rs
index 18b6b58c8..7432b54d8 100644
--- a/src/ff/galois_field.rs
+++ b/src/ff/galois_field.rs
@@ -5,7 +5,7 @@ use std::{
 
 use bitvec::prelude::{bitarr, BitArr, Lsb0};
 use generic_array::GenericArray;
-use typenum::{Unsigned, U1, U4, U5};
+use typenum::{Unsigned, U1, U2, U4, U5};
 
 use crate::{
     ff::{Field, Serializable},
@@ -25,6 +25,7 @@ pub trait GaloisField:
 
 // Bit store type definitions
 type U8_1 = BitArr!(for 8, in u8, Lsb0);
+type U8_2 = BitArr!(for 9, in u8, Lsb0);
 type U8_4 = BitArr!(for 32, in u8, Lsb0);
 type U8_5 = BitArr!(for 40, in u8, Lsb0);
 
@@ -32,6 +33,10 @@ impl Block for U8_1 {
     type Size = U1;
 }
 
+impl Block for U8_2 {
+    type Size = U2;
+}
+
 impl Block for U8_4 {
     type Size = U4;
 }
@@ -560,6 +565,16 @@ bit_array_impl!(
     0b1_0001_1011_u128
 );
 
+bit_array_impl!(
+    bit_array_9,
+    Gf9Bit,
+    U8_2,
+    9,
+    bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0, 0),
+    // x^9 + x^4 + x^3 + x + 1
+    0b10_0001_1011_u128
+);
+
 bit_array_impl!(
     bit_array_5,
     Gf5Bit,
diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 5544f2378..1cb8c0c43 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -9,7 +9,7 @@ mod prime_field;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 
 pub use field::{Field, FieldType};
-pub use galois_field::{GaloisField, Gf2, Gf32Bit, Gf3Bit, Gf40Bit, Gf5Bit, Gf8Bit};
+pub use galois_field::{GaloisField, Gf2, Gf32Bit, Gf3Bit, Gf40Bit, Gf5Bit, Gf8Bit, Gf9Bit};
 use generic_array::{ArrayLength, GenericArray};
 #[cfg(any(test, feature = "weak-field"))]
 pub use prime_field::Fp31;
diff --git a/src/protocol/prf_sharding/bucket.rs b/src/protocol/prf_sharding/bucket.rs
index d199557bd..d2ad77a11 100644
--- a/src/protocol/prf_sharding/bucket.rs
+++ b/src/protocol/prf_sharding/bucket.rs
@@ -18,9 +18,16 @@ pub enum BucketStep {
     Bit(usize),
 }
 
-impl From<u32> for BucketStep {
-    fn from(v: u32) -> Self {
-        Self::Bit(usize::try_from(v).unwrap())
+impl TryFrom<u32> for BucketStep {
+    type Error = String;
+
+    fn try_from(v: u32) -> Result<Self, Self::Error> {
+        let val = usize::try_from(v);
+        let val = match val {
+            Ok(val) => Self::Bit(val),
+            Err(error) => panic!("{error:?}"),
+        };
+        Ok(val)
     }
 }
 
@@ -114,7 +121,7 @@ pub mod tests {
     use rand::thread_rng;
 
     use crate::{
-        ff::{Field, Fp32BitPrime, Gf8Bit},
+        ff::{Field, Fp32BitPrime, Gf8Bit, Gf9Bit},
         protocol::{
             context::{Context, UpgradableContext, Validator},
             prf_sharding::bucket::move_single_value_to_bucket,
@@ -225,7 +232,7 @@ pub mod tests {
     #[should_panic]
     fn move_out_of_range_too_many_buckets_steps() {
         run(move || async move {
-            let breakdown_key_bits = get_bits::<Fp32BitPrime>(0, Gf8Bit::BITS);
+            let breakdown_key_bits = get_bits::<Fp32BitPrime>(0, Gf9Bit::BITS);
             let value = Fp32BitPrime::truncate_from(VALUE);
 
             _ = TestWorld::default()
@@ -234,7 +241,7 @@ pub mod tests {
                     |ctx, (breakdown_key_share, value_share)| async move {
                         let validator = ctx.validator();
                         let ctx = validator.context();
-                        move_single_value_to_bucket::<Gf8Bit, _, _, Fp32BitPrime>(
+                        move_single_value_to_bucket::<Gf9Bit, _, _, Fp32BitPrime>(
                             ctx.set_total_records(1),
                             RecordId::from(0),
                             breakdown_key_share,
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 4412d0e0a..94250fdfa 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1003,4 +1003,27 @@ pub mod tests {
             assert_eq!(result, &expected);
         });
     }
+
+    #[test]
+    fn semi_honest_aggregation_empty_input() {
+        run(|| async move {
+            let world = TestWorld::default();
+
+            let records: Vec<PreAggregationTestInputInBits> = vec![];
+
+            let expected = [0_u128; 32];
+
+            let result: Vec<_> = world
+                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
+                    let validator = ctx.validator();
+                    let ctx = validator.context();
+                    do_aggregation::<_, Gf5Bit, Gf3Bit, Fp32BitPrime, _>(ctx, input_rows)
+                        .await
+                        .unwrap()
+                })
+                .await
+                .reconstruct();
+            assert_eq!(result, &expected);
+        });
+    }
 }

From 5ea37ca4b61a908039d6e18fd91be5f5345f9515 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Wed, 25 Oct 2023 14:54:23 +0800
Subject: [PATCH 065/105] Supporting the opposite capping logic

---
 src/test_fixture/ipa.rs | 52 ++++++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index 37e31b535..ef7b32c8a 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -77,12 +77,18 @@ pub fn ipa_in_the_clear(
             &mut breakdowns,
             per_user_cap,
             attribution_window,
+            CappingOrder::CapOldestFirst,
         );
     }
 
     breakdowns
 }
 
+enum CappingOrder {
+    CapOldestFirst,
+    CapMostRecentFirst,
+}
+
 /// Assumes records all belong to the same user, and are in reverse chronological order
 /// Will give incorrect results if this is not true
 #[allow(clippy::missing_panics_doc)]
@@ -91,6 +97,7 @@ fn update_expected_output_for_user<'a, I: IntoIterator<Item = &'a TestRawDataRec
     expected_results: &mut [u32],
     per_user_cap: u32,
     attribution_window_seconds: Option<NonZeroU32>,
+    order: CappingOrder,
 ) {
     let within_window = |value: u64| -> bool {
         if let Some(window) = attribution_window_seconds {
@@ -102,17 +109,13 @@ fn update_expected_output_for_user<'a, I: IntoIterator<Item = &'a TestRawDataRec
         }
     };
 
+    let mut attributed_triggers = Vec::new();
     let mut pending_trigger_reports = Vec::new();
-    let mut total_contribution = 0;
     for record in records_for_user {
-        if total_contribution >= per_user_cap {
-            break;
-        }
-
         if record.is_trigger_report {
             pending_trigger_reports.push(record);
         } else if !pending_trigger_reports.is_empty() {
-            for trigger_report in &pending_trigger_reports {
+            for trigger_report in pending_trigger_reports.into_iter() {
                 let time_delta_to_source_report = trigger_report.timestamp - record.timestamp;
 
                 // only count trigger reports that are within the attribution window
@@ -121,16 +124,39 @@ fn update_expected_output_for_user<'a, I: IntoIterator<Item = &'a TestRawDataRec
                     continue;
                 }
 
-                let delta_to_per_user_cap = per_user_cap - total_contribution;
-                let capped_contribution =
-                    std::cmp::min(delta_to_per_user_cap, trigger_report.trigger_value);
-                let bk: usize = record.breakdown_key.try_into().unwrap();
-                expected_results[bk] += capped_contribution;
-                total_contribution += capped_contribution;
+                attributed_triggers.push((trigger_report, record));
             }
-            pending_trigger_reports.clear();
+            pending_trigger_reports = Vec::new();
         }
     }
+
+    match order {
+        CappingOrder::CapOldestFirst => update_breakdowns(
+            attributed_triggers.into_iter(),
+            expected_results,
+            per_user_cap,
+        ),
+        CappingOrder::CapMostRecentFirst => update_breakdowns(
+            attributed_triggers.into_iter().rev(),
+            expected_results,
+            per_user_cap,
+        ),
+    }
+}
+
+fn update_breakdowns<'a, I>(attributed_triggers: I, expected_results: &mut [u32], per_user_cap: u32)
+where
+    I: IntoIterator<Item = (&'a TestRawDataRecord, &'a TestRawDataRecord)>,
+{
+    let mut total_contribution = 0;
+    for (trigger_report, source_report) in attributed_triggers {
+        let delta_to_per_user_cap = per_user_cap - total_contribution;
+        let capped_contribution =
+            std::cmp::min(delta_to_per_user_cap, trigger_report.trigger_value);
+        let bk: usize = source_report.breakdown_key.try_into().unwrap();
+        expected_results[bk] += capped_contribution;
+        total_contribution += capped_contribution;
+    }
 }
 
 /// # Panics

From dd07816234150a9c49b74bdfece59ea14e6009e9 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Wed, 25 Oct 2023 15:32:31 +0800
Subject: [PATCH 066/105] Peer feedback

---
 benches/oneshot/ipa.rs           |  8 +++++++-
 pre-commit                       |  6 +++++-
 scripts/collect_steps.py         |  3 ++-
 src/bin/report_collector.rs      |  1 +
 src/protocol/ipa/mod.rs          |  3 ++-
 src/protocol/prf_sharding/mod.rs | 10 +++++-----
 src/test_fixture/ipa.rs          | 28 ++++++++++++++++++----------
 7 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/benches/oneshot/ipa.rs b/benches/oneshot/ipa.rs
index ab6e723e2..ae8826f6a 100644
--- a/benches/oneshot/ipa.rs
+++ b/benches/oneshot/ipa.rs
@@ -9,7 +9,7 @@ use ipa::{
     ff::Fp32BitPrime,
     helpers::{query::IpaQueryConfig, GatewayConfig},
     test_fixture::{
-        ipa::{ipa_in_the_clear, test_ipa, test_oprf_ipa, IpaSecurityModel},
+        ipa::{ipa_in_the_clear, test_ipa, test_oprf_ipa, CappingOrder, IpaSecurityModel},
         EventGenerator, EventGeneratorConfig, TestWorld, TestWorldConfig,
     },
 };
@@ -123,11 +123,17 @@ async fn run(args: Args) -> Result<(), Error> {
     .take(args.query_size)
     .collect::<Vec<_>>();
 
+    let order = if args.oprf {
+        CappingOrder::CapOldestFirst
+    } else {
+        CappingOrder::CapMostRecentFirst
+    };
     let expected_results = ipa_in_the_clear(
         &raw_data,
         args.per_user_cap,
         args.attribution_window(),
         args.breakdown_keys,
+        &order,
     );
 
     let world = TestWorld::new_with(config.clone());
diff --git a/pre-commit b/pre-commit
index 6cf2be072..c60774f4d 100755
--- a/pre-commit
+++ b/pre-commit
@@ -99,8 +99,12 @@ check "Concurrency tests" \
 check "IPA benchmark" \
     cargo bench --bench oneshot_ipa --no-default-features --features="enable-benches descriptive-gate" -- -n 62
 
+check "IPA OPRF benchmark" \
+    cargo bench --bench oneshot_ipa --no-default-features --features="enable-benches descriptive-gate" -- -n 62 --oprf
+
 check "Arithmetic circuit benchmark" \
     cargo bench --bench oneshot_arithmetic --no-default-features --features "enable-benches descriptive-gate"
 
 check "Sort benchmark" \
-    cargo bench --bench oneshot_sort --no-default-features --features="enable-benches descriptive-gate"
\ No newline at end of file
+    cargo bench --bench oneshot_sort --no-default-features --features="enable-benches descriptive-gate"
+
diff --git a/scripts/collect_steps.py b/scripts/collect_steps.py
index 9664a1c06..3e87d3a2f 100755
--- a/scripts/collect_steps.py
+++ b/scripts/collect_steps.py
@@ -206,4 +206,5 @@ def oprf_steps(steps):
     sorted_steps = sorted(full_steps)
 
     for step in sorted_steps:
-        print(step)
\ No newline at end of file
+        print(step)
+        
\ No newline at end of file
diff --git a/src/bin/report_collector.rs b/src/bin/report_collector.rs
index bac36b0db..fb55cd2a1 100644
--- a/src/bin/report_collector.rs
+++ b/src/bin/report_collector.rs
@@ -247,6 +247,7 @@ async fn ipa(
             ipa_query_config.per_user_credit_cap,
             ipa_query_config.attribution_window_seconds,
             ipa_query_config.max_breakdown_key,
+            CappingOrder::CapOldestFirst,
         );
 
         // pad the output vector to the max breakdown key, to make sure it is aligned with the MPC results
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index b8f516684..bac3d6e82 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -464,7 +464,7 @@ pub mod tests {
         test_executor::{run, run_with},
         test_fixture::{
             input::GenericReportTestInput,
-            ipa::{ipa_in_the_clear, test_ipa, IpaSecurityModel},
+            ipa::{ipa_in_the_clear, test_ipa, CappingOrder, IpaSecurityModel},
             logging, EventGenerator, EventGeneratorConfig, Reconstruct, Runner, TestWorld,
             TestWorldConfig,
         },
@@ -815,6 +815,7 @@ pub mod tests {
                 per_user_cap,
                 ATTRIBUTION_WINDOW_SECONDS,
                 MAX_BREAKDOWN_KEY,
+                &CappingOrder::CapOldestFirst,
             );
 
             let config = TestWorldConfig {
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index a0e7909fa..87832f797 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -37,11 +37,11 @@ pub mod bucket;
 pub mod feature_label_dot_product;
 
 pub struct PrfShardedIpaInputRow<BK: GaloisField, TV: GaloisField, TS: GaloisField> {
-    prf_of_match_key: u64,
-    is_trigger_bit: Replicated<Gf2>,
-    breakdown_key: Replicated<BK>,
-    trigger_value: Replicated<TV>,
-    timestamp: Replicated<TS>,
+    pub prf_of_match_key: u64,
+    pub is_trigger_bit: Replicated<Gf2>,
+    pub breakdown_key: Replicated<BK>,
+    pub trigger_value: Replicated<TV>,
+    pub timestamp: Replicated<TS>,
 }
 
 impl<BK: GaloisField, TV: GaloisField, TS: GaloisField> PrfShardedIpaInputRow<BK, TV, TS> {
diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index 153ce77e3..a33b92e5b 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -48,6 +48,7 @@ pub fn ipa_in_the_clear(
     per_user_cap: u32,
     attribution_window: Option<NonZeroU32>,
     max_breakdown: u32,
+    order: &CappingOrder,
 ) -> Vec<u32> {
     // build a view that is convenient for attribution. match key -> events sorted by timestamp in reverse
     // that is more memory intensive, but should be faster to compute. We can always opt-out and
@@ -81,14 +82,14 @@ pub fn ipa_in_the_clear(
             &mut breakdowns,
             per_user_cap,
             attribution_window,
-            CappingOrder::CapOldestFirst,
+            order,
         );
     }
 
     breakdowns
 }
 
-enum CappingOrder {
+pub enum CappingOrder {
     CapOldestFirst,
     CapMostRecentFirst,
 }
@@ -101,7 +102,7 @@ fn update_expected_output_for_user<'a, I: IntoIterator<Item = &'a TestRawDataRec
     expected_results: &mut [u32],
     per_user_cap: u32,
     attribution_window_seconds: Option<NonZeroU32>,
-    order: CappingOrder,
+    order: &CappingOrder,
 ) {
     let within_window = |value: u64| -> bool {
         if let Some(window) = attribution_window_seconds {
@@ -119,7 +120,7 @@ fn update_expected_output_for_user<'a, I: IntoIterator<Item = &'a TestRawDataRec
         if record.is_trigger_report {
             pending_trigger_reports.push(record);
         } else if !pending_trigger_reports.is_empty() {
-            for trigger_report in pending_trigger_reports.into_iter() {
+            for trigger_report in pending_trigger_reports {
                 let time_delta_to_source_report = trigger_report.timestamp - record.timestamp;
 
                 // only count trigger reports that are within the attribution window
@@ -135,11 +136,9 @@ fn update_expected_output_for_user<'a, I: IntoIterator<Item = &'a TestRawDataRec
     }
 
     match order {
-        CappingOrder::CapOldestFirst => update_breakdowns(
-            attributed_triggers.into_iter(),
-            expected_results,
-            per_user_cap,
-        ),
+        CappingOrder::CapOldestFirst => {
+            update_breakdowns(attributed_triggers, expected_results, per_user_cap);
+        }
         CappingOrder::CapMostRecentFirst => update_breakdowns(
             attributed_triggers.into_iter().rev(),
             expected_results,
@@ -272,6 +271,7 @@ pub async fn test_oprf_ipa<F>(
                             is_trigger_bit: is_trigger_bit_share,
                             breakdown_key: single_row.breakdown_key,
                             trigger_value: single_row.trigger_value,
+                            timestamp: single_row.timestamp,
                         }
                     })
                     .collect::<Vec<_>>();
@@ -280,10 +280,16 @@ pub async fn test_oprf_ipa<F>(
                     _,
                     BreakdownKey,
                     TriggerValue,
+                    Timestamp,
                     F,
                     _,
                     Replicated<Gf2>,
-                >(ctx, sharded_input, user_cap.ilog2().try_into().unwrap())
+                >(
+                    ctx,
+                    sharded_input,
+                    user_cap.ilog2().try_into().unwrap(),
+                    config.attribution_window_seconds,
+                )
                 .await
                 .unwrap()
             },
@@ -295,6 +301,8 @@ pub async fn test_oprf_ipa<F>(
         .into_iter()
         .map(|v| u32::try_from(v.as_u128()).unwrap())
         .collect::<Vec<_>>();
+
+    //TODO(richaj): To be removed once the function supports non power of 2 breakdowns
     let _ = result.split_off(expected_results.len());
     assert_eq!(result, expected_results);
 }

From 51e05fe4c6b6682893b5db65f7c6d84384f538f0 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Wed, 25 Oct 2023 16:42:39 +0800
Subject: [PATCH 067/105] Some more fixes

---
 benches/oneshot/ipa.rs            |   4 +-
 pre-commit                        |   1 -
 scripts/collect_steps.py          |   6 +-
 src/bin/report_collector.rs       |   4 +-
 src/protocol/step/steps.txt       | 238 +++++++++++++++++++++++++++++-
 src/test_fixture/input/sharing.rs |  11 +-
 steps1.txt                        |   1 +
 7 files changed, 251 insertions(+), 14 deletions(-)
 create mode 100644 steps1.txt

diff --git a/benches/oneshot/ipa.rs b/benches/oneshot/ipa.rs
index ae8826f6a..c597b7e29 100644
--- a/benches/oneshot/ipa.rs
+++ b/benches/oneshot/ipa.rs
@@ -124,9 +124,9 @@ async fn run(args: Args) -> Result<(), Error> {
     .collect::<Vec<_>>();
 
     let order = if args.oprf {
-        CappingOrder::CapOldestFirst
-    } else {
         CappingOrder::CapMostRecentFirst
+    } else {
+        CappingOrder::CapOldestFirst
     };
     let expected_results = ipa_in_the_clear(
         &raw_data,
diff --git a/pre-commit b/pre-commit
index c60774f4d..40dcbf745 100755
--- a/pre-commit
+++ b/pre-commit
@@ -107,4 +107,3 @@ check "Arithmetic circuit benchmark" \
 
 check "Sort benchmark" \
     cargo bench --bench oneshot_sort --no-default-features --features="enable-benches descriptive-gate"
-
diff --git a/scripts/collect_steps.py b/scripts/collect_steps.py
index 3e87d3a2f..3e1371ef2 100755
--- a/scripts/collect_steps.py
+++ b/scripts/collect_steps.py
@@ -169,14 +169,15 @@ def ipa_steps(steps):
                     print(" ".join(args), file=sys.stderr)
                     steps.update(collect_steps(args))
 
+OPRF_BREAKDOWN_KEYS = [256]
 OPRF_USER_CAP = [16, 64, 128]
 OPRF_SECURITY_MODEL = ["semi-honest"]
-OPRF_TRIGGER_VALUE = [4]
+OPRF_TRIGGER_VALUE = [7]
 
 def oprf_steps(steps):
     for c in OPRF_USER_CAP:
         for w in ATTRIBUTION_WINDOW:
-            for b in BREAKDOWN_KEYS:
+            for b in OPRF_BREAKDOWN_KEYS:
                 for m in OPRF_SECURITY_MODEL:
                     for tv in OPRF_TRIGGER_VALUE:
                         args = ARGS + [
@@ -207,4 +208,3 @@ def oprf_steps(steps):
 
     for step in sorted_steps:
         print(step)
-        
\ No newline at end of file
diff --git a/src/bin/report_collector.rs b/src/bin/report_collector.rs
index fb55cd2a1..a8ca7ba82 100644
--- a/src/bin/report_collector.rs
+++ b/src/bin/report_collector.rs
@@ -26,7 +26,7 @@ use ipa::{
     protocol::{BreakdownKey, MatchKey},
     report::{KeyIdentifier, DEFAULT_KEY_ID},
     test_fixture::{
-        ipa::{ipa_in_the_clear, IpaSecurityModel, TestRawDataRecord},
+        ipa::{ipa_in_the_clear, CappingOrder, IpaSecurityModel, TestRawDataRecord},
         EventGenerator, EventGeneratorConfig,
     },
 };
@@ -247,7 +247,7 @@ async fn ipa(
             ipa_query_config.per_user_credit_cap,
             ipa_query_config.attribution_window_seconds,
             ipa_query_config.max_breakdown_key,
-            CappingOrder::CapOldestFirst,
+            &CappingOrder::CapOldestFirst,
         );
 
         // pad the output vector to the max breakdown key, to make sure it is aligned with the MPC results
diff --git a/src/protocol/step/steps.txt b/src/protocol/step/steps.txt
index 042e01c6f..2079b4ee3 100644
--- a/src/protocol/step/steps.txt
+++ b/src/protocol/step/steps.txt
@@ -9180,6 +9180,52 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
@@ -9204,9 +9250,29 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
@@ -9218,6 +9284,52 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
@@ -9233,7 +9345,6 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
@@ -9242,6 +9353,127 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
diff --git a/src/test_fixture/input/sharing.rs b/src/test_fixture/input/sharing.rs
index 1287ad8e0..e5e306e7d 100644
--- a/src/test_fixture/input/sharing.rs
+++ b/src/test_fixture/input/sharing.rs
@@ -367,9 +367,14 @@ where
         } else {
             EventType::Source
         };
-        let timestamp = TS::truncate_from(self.timestamp).share_with(rng);
-        let breakdown_key = BK::truncate_from(self.breakdown_key).share_with(rng);
-        let trigger_value = TV::truncate_from(self.trigger_value).share_with(rng);
+        let timestamp: [Replicated<TS>; 3] =
+            TS::try_from(self.timestamp.into()).unwrap().share_with(rng);
+        let breakdown_key = BK::try_from(self.breakdown_key.into())
+            .unwrap()
+            .share_with(rng);
+        let trigger_value = TV::try_from(self.trigger_value.into())
+            .unwrap()
+            .share_with(rng);
 
         zip(zip(timestamp, breakdown_key), trigger_value)
             .map(|((ts_share, bk_share), tv_share)| OprfReport {
diff --git a/steps1.txt b/steps1.txt
new file mode 100644
index 000000000..ff3d9f397
--- /dev/null
+++ b/steps1.txt
@@ -0,0 +1 @@
+No steps in the output

From d8c059871721e8b61f19fa441c3951517b9f2ede Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Wed, 25 Oct 2023 23:45:20 +0800
Subject: [PATCH 068/105] Some code refactor based on Taiki's feedback

---
 0001-CI-split-extra-step-into-two.patch | 88 -------------------------
 pre-commit                              |  2 +-
 scripts/collect_steps.py                | 58 ++++++++--------
 src/protocol/step/steps.txt             |  4 ++
 steps1.txt                              |  1 -
 5 files changed, 35 insertions(+), 118 deletions(-)
 delete mode 100644 0001-CI-split-extra-step-into-two.patch
 delete mode 100644 steps1.txt

diff --git a/0001-CI-split-extra-step-into-two.patch b/0001-CI-split-extra-step-into-two.patch
deleted file mode 100644
index 85d7146d2..000000000
--- a/0001-CI-split-extra-step-into-two.patch
+++ /dev/null
@@ -1,88 +0,0 @@
-From ba6c503fbe930a9298d83c04bab15f329faf13ae Mon Sep 17 00:00:00 2001
-From: Alex Koshelev <koshelev@meta.com>
-Date: Fri, 11 Aug 2023 14:25:03 -0700
-Subject: [PATCH] CI: split extra step into two
-
-This is an attempt to increase parallelism on CI. Those builds take ~4 mins and running tests take another 5-6 mins. Splitting this step should make CI run faster.
----
- .github/workflows/check.yml | 42 ++++++++++++++++++++++++++++---------
- 1 file changed, 32 insertions(+), 10 deletions(-)
-
-diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
-index 54f869ac..9a8e1886 100644
---- a/.github/workflows/check.yml
-+++ b/.github/workflows/check.yml
-@@ -15,13 +15,15 @@ on:
-       - "benches/**/*"
-       - "tests/**/*"
- 
-+env:
-+  CARGO_TERM_COLOR: always
-+  RUSTFLAGS: -D warnings
-+  RUSTDOCFLAGS: -D warnings
-+
- jobs:
-   basic:
-     name: Basic Checks
-     env:
--      CARGO_TERM_COLOR: always
--      RUSTFLAGS: -D warnings
--      RUSTDOCFLAGS: -D warnings
-       CARGO_INCREMENTAL: 0
- 
-     runs-on: ubuntu-latest
-@@ -64,12 +66,13 @@ jobs:
-       - name: Run Web Tests
-         run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture descriptive-gate"
- 
--  extra:
--    name: Additional Builds and Concurrency Tests
-+      - name: Run compact gate tests
-+        run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture compact-gate"
-+
-+  extra-builds:
-+    name: Additional Builds
-     env:
--      CARGO_TERM_COLOR: always
-       RUSTFLAGS: -D warnings -C target-cpu=native
--      RUSTDOCFLAGS: -D warnings
- 
-     runs-on: ubuntu-latest
- 
-@@ -102,11 +105,30 @@ jobs:
-       - name: Build concurrency tests (debug mode)
-         run: cargo build --features shuttle
- 
-+  benches-and-fuzzy:
-+    name: Run benchmarks and concurrency tests
-+
-+    runs-on: ubuntu-latest
-+
-+    steps:
-+      - uses: actions/checkout@v3
-+
-+      - uses: dtolnay/rust-toolchain@stable
-+        with:
-+          components: clippy,rustfmt
-+
-+      - uses: actions/cache@v3
-+        with:
-+          path: |
-+            ~/.cargo/bin/
-+            ~/.cargo/registry/index/
-+            ~/.cargo/registry/cache/
-+            ~/.cargo/git/db/
-+            target/
-+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.toml') }}
-+
-       - name: Run concurrency tests
-         run: cargo test --release --features shuttle
- 
-       - name: Run IPA bench
-         run: cargo bench --bench oneshot_ipa --no-default-features --features "enable-benches descriptive-gate"
--
--      - name: Run compact gate tests
--        run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture compact-gate"
--- 
-2.31.1
-
diff --git a/pre-commit b/pre-commit
index 40dcbf745..d60bece9e 100755
--- a/pre-commit
+++ b/pre-commit
@@ -100,7 +100,7 @@ check "IPA benchmark" \
     cargo bench --bench oneshot_ipa --no-default-features --features="enable-benches descriptive-gate" -- -n 62
 
 check "IPA OPRF benchmark" \
-    cargo bench --bench oneshot_ipa --no-default-features --features="enable-benches descriptive-gate" -- -n 62 --oprf
+    cargo bench --bench oneshot_ipa --no-default-features --features="enable-benches descriptive-gate" -- -n 62 --oprf -c 16
 
 check "Arithmetic circuit benchmark" \
     cargo bench --bench oneshot_arithmetic --no-default-features --features "enable-benches descriptive-gate"
diff --git a/scripts/collect_steps.py b/scripts/collect_steps.py
index 3e1371ef2..23c8ffc5e 100755
--- a/scripts/collect_steps.py
+++ b/scripts/collect_steps.py
@@ -149,7 +149,8 @@ def extract_intermediate_steps(steps):
 
     return steps
 
-def ipa_steps(steps):
+def ipa_steps():
+    output = set()
     for c in PER_USER_CAP:
         for w in ATTRIBUTION_WINDOW:
             for b in BREAKDOWN_KEYS:
@@ -167,41 +168,42 @@ def ipa_steps(steps):
                         m,
                     ]
                     print(" ".join(args), file=sys.stderr)
-                    steps.update(collect_steps(args))
+                    output.update(collect_steps(args))
+    return output
 
-OPRF_BREAKDOWN_KEYS = [256]
+OPRF_BREAKDOWN_KEY = 256
 OPRF_USER_CAP = [16, 64, 128]
-OPRF_SECURITY_MODEL = ["semi-honest"]
-OPRF_TRIGGER_VALUE = [7]
+OPRF_SECURITY_MODEL = "semi-honest"
+OPRF_TRIGGER_VALUE = [6, 7]
 
-def oprf_steps(steps):
+def oprf_steps():
+    output = set()
     for c in OPRF_USER_CAP:
         for w in ATTRIBUTION_WINDOW:
-            for b in OPRF_BREAKDOWN_KEYS:
-                for m in OPRF_SECURITY_MODEL:
-                    for tv in OPRF_TRIGGER_VALUE:
-                        args = ARGS + [
-                            "-n",
-                            str(QUERY_SIZE),
-                            "-c",
-                            str(c),
-                            "-w",
-                            str(w),
-                            "-b",
-                            str(b),
-                            "-m",
-                            m,
-                            "-t",
-                            str(tv),
-                            "-o"
-                        ]
-                    print(" ".join(args), file=sys.stderr)
-                    steps.update(collect_steps(args))
+            for tv in OPRF_TRIGGER_VALUE:
+                args = ARGS + [
+                    "-n",
+                    str(QUERY_SIZE),
+                    "-c",
+                    str(c),
+                    "-w",
+                    str(w),
+                    "-b",
+                    str(OPRF_BREAKDOWN_KEY),
+                    "-m",
+                    OPRF_SECURITY_MODEL,
+                    "-t",
+                    str(tv),
+                    "-o"
+            ]
+            print(" ".join(args), file=sys.stderr)
+            output.update(collect_steps(args))
+    return output
 
 if __name__ == "__main__":
     steps = set()
-    ipa_steps(steps)
-    oprf_steps(steps)
+    steps.update(ipa_steps())
+    steps.update(oprf_steps())
 
     full_steps = extract_intermediate_steps(steps)
     sorted_steps = sorted(full_steps)
diff --git a/src/protocol/step/steps.txt b/src/protocol/step/steps.txt
index 2079b4ee3..c5bafcded 100644
--- a/src/protocol/step/steps.txt
+++ b/src/protocol/step/steps.txt
@@ -9345,6 +9345,7 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
@@ -9446,6 +9447,9 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
diff --git a/steps1.txt b/steps1.txt
deleted file mode 100644
index ff3d9f397..000000000
--- a/steps1.txt
+++ /dev/null
@@ -1 +0,0 @@
-No steps in the output

From 31a155c6067ca4546f7073db0116548490e965a4 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Thu, 26 Oct 2023 14:27:51 +0800
Subject: [PATCH 069/105] OPRF test on real world infra

---
 src/bin/report_collector.rs    |  67 ++++++++++++-----
 src/cli/playbook/ipa.rs        |  95 +++++++++++++++++++++++-
 src/cli/playbook/mod.rs        |   3 +-
 src/helpers/transport/query.rs |   3 +
 src/net/http_serde.rs          |   8 ++-
 src/query/executor.rs          |  28 ++++++++
 src/query/runner/mod.rs        |   4 +-
 src/query/runner/oprf_ipa.rs   | 127 +++++++++++++++++++++++++++++++++
 src/report.rs                  |  94 +++++++++++++++++++++++-
 9 files changed, 404 insertions(+), 25 deletions(-)
 create mode 100644 src/query/runner/oprf_ipa.rs

diff --git a/src/bin/report_collector.rs b/src/bin/report_collector.rs
index a8ca7ba82..89b80bb0e 100644
--- a/src/bin/report_collector.rs
+++ b/src/bin/report_collector.rs
@@ -15,7 +15,7 @@ use hyper::http::uri::Scheme;
 use ipa::{
     cli::{
         noise::{apply, ApplyDpArgs},
-        playbook::{make_clients, playbook_ipa, validate, InputSource},
+        playbook::{make_clients, playbook_ipa, playbook_oprf_ipa, validate, InputSource},
         CsvSerializer, IpaQueryResult, Verbosity,
     },
     config::NetworkConfig,
@@ -103,6 +103,8 @@ enum ReportCollectorCommand {
     },
     /// Apply differential privacy noise to IPA inputs
     ApplyDpNoise(ApplyDpArgs),
+    /// Execute OPRF IPA in a semi-honest majority setting
+    OprfIpa(IpaQueryConfig),
 }
 
 #[derive(Debug, clap::Args)]
@@ -134,6 +136,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 IpaSecurityModel::SemiHonest,
                 config,
                 &clients,
+                false,
             )
             .await?
         }
@@ -144,6 +147,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 IpaSecurityModel::Malicious,
                 config,
                 &clients,
+                false,
             )
             .await?
         }
@@ -153,6 +157,17 @@ async fn main() -> Result<(), Box<dyn Error>> {
             gen_args,
         } => gen_inputs(count, seed, args.output_file, gen_args)?,
         ReportCollectorCommand::ApplyDpNoise(ref dp_args) => apply_dp_noise(&args, dp_args)?,
+        ReportCollectorCommand::OprfIpa(config) => {
+            ipa(
+                &args,
+                &network,
+                IpaSecurityModel::SemiHonest,
+                config,
+                &clients,
+                true,
+            )
+            .await?
+        }
     };
 
     Ok(())
@@ -221,16 +236,29 @@ async fn ipa(
     security_model: IpaSecurityModel,
     ipa_query_config: IpaQueryConfig,
     helper_clients: &[MpcHelperClient; 3],
+    oprf_algorithm: bool,
 ) -> Result<(), Box<dyn Error>> {
     let input = InputSource::from(&args.input);
     let query_type: QueryType;
-    match security_model {
-        IpaSecurityModel::SemiHonest => {
+    match (security_model, oprf_algorithm) {
+        (IpaSecurityModel::SemiHonest, false) => {
             query_type = QueryType::SemiHonestIpa(ipa_query_config.clone());
         }
-        IpaSecurityModel::Malicious => {
+        (IpaSecurityModel::Malicious, false) => {
             query_type = QueryType::MaliciousIpa(ipa_query_config.clone())
         }
+        (IpaSecurityModel::SemiHonest, true) => {
+            query_type = QueryType::OprfIpa(ipa_query_config.clone());
+        }
+        (IpaSecurityModel::Malicious, true) => {
+            panic!("OPRF for malicious is not implemented as yet")
+        }
+    };
+
+    let order = if oprf_algorithm {
+        CappingOrder::CapMostRecentFirst
+    } else {
+        CappingOrder::CapOldestFirst
     };
 
     let input_rows = input.iter::<TestRawDataRecord>().collect::<Vec<_>>();
@@ -247,7 +275,7 @@ async fn ipa(
             ipa_query_config.per_user_credit_cap,
             ipa_query_config.attribution_window_seconds,
             ipa_query_config.max_breakdown_key,
-            &CappingOrder::CapOldestFirst,
+            &order,
         );
 
         // pad the output vector to the max breakdown key, to make sure it is aligned with the MPC results
@@ -260,18 +288,19 @@ async fn ipa(
     };
 
     let mut key_registries = KeyRegistries::default();
-    let actual = playbook_ipa::<Fp32BitPrime, MatchKey, BreakdownKey, _>(
-        &input_rows,
-        &helper_clients,
-        query_id,
-        ipa_query_config,
-        key_registries.init_from(network),
-    )
-    .await;
-
-    tracing::info!("{m:?}", m = ipa_query_config);
-
-    validate(&expected, &actual.breakdowns);
+    let actual = if oprf_algorithm {
+        playbook_oprf_ipa::<Fp32BitPrime>(input_rows, &helper_clients, query_id, ipa_query_config)
+            .await
+    } else {
+        playbook_ipa::<Fp32BitPrime, MatchKey, BreakdownKey, _>(
+            &input_rows,
+            &helper_clients,
+            query_id,
+            ipa_query_config,
+            key_registries.init_from(network),
+        )
+        .await
+    };
 
     if let Some(ref path) = args.output_file {
         // it will be sad to lose the results if file already exists.
@@ -308,6 +337,10 @@ async fn ipa(
         write!(file, "{}", serde_json::to_string_pretty(&actual)?)?;
     }
 
+    tracing::info!("{m:?}", m = ipa_query_config);
+
+    validate(&expected, &actual.breakdowns);
+
     Ok(())
 }
 
diff --git a/src/cli/playbook/ipa.rs b/src/cli/playbook/ipa.rs
index 9047baeb3..c509cb400 100644
--- a/src/cli/playbook/ipa.rs
+++ b/src/cli/playbook/ipa.rs
@@ -22,9 +22,9 @@ use crate::{
     hpke::PublicKeyRegistry,
     ipa_test_input,
     net::MpcHelperClient,
-    protocol::{ipa::IPAInputRow, BreakdownKey, MatchKey, QueryId},
+    protocol::{ipa::IPAInputRow, BreakdownKey, MatchKey, QueryId, Timestamp, TriggerValue},
     query::QueryStatus,
-    report::{KeyIdentifier, Report},
+    report::{KeyIdentifier, OprfReport, Report},
     secret_sharing::{replicated::semi_honest::AdditiveShare, IntoShares},
     test_fixture::{input::GenericReportTestInput, ipa::TestRawDataRecord, Reconstruct},
 };
@@ -158,3 +158,94 @@ where
         breakdowns,
     }
 }
+
+pub async fn playbook_oprf_ipa<F>(
+    mut records: Vec<TestRawDataRecord>,
+    clients: &[MpcHelperClient; 3],
+    query_id: QueryId,
+    query_config: IpaQueryConfig,
+) -> IpaQueryResult
+where
+    F: PrimeField,
+    AdditiveShare<F>: Serializable,
+{
+    let mut buffers: [_; 3] = std::array::from_fn(|_| Vec::new());
+    let query_size = records.len();
+
+    let sz = <OprfReport<Timestamp, BreakdownKey, TriggerValue> as Serializable>::Size::USIZE;
+    for buffer in &mut buffers {
+        buffer.resize(query_size * sz, 0u8);
+    }
+
+    //TODO(richaj) This manual sorting will be removed once we have the PRF sharding in place
+    records.sort_by(|a, b| b.user_id.cmp(&a.user_id));
+
+    let shares: [Vec<OprfReport<Timestamp, BreakdownKey, TriggerValue>>; 3] =
+        records.iter().cloned().share();
+    zip(&mut buffers, shares).for_each(|(buf, shares)| {
+        for (share, chunk) in zip(shares, buf.chunks_mut(sz)) {
+            share.serialize(GenericArray::from_mut_slice(chunk));
+        }
+    });
+
+    let inputs = buffers.map(BodyStream::from);
+    tracing::info!("Starting query for OPRF");
+    let mpc_time = Instant::now();
+    try_join_all(
+        inputs
+            .into_iter()
+            .zip(clients)
+            .map(|(input_stream, client)| {
+                client.query_input(QueryInput {
+                    query_id,
+                    input_stream,
+                })
+            }),
+    )
+    .await
+    .unwrap();
+
+    let mut delay = Duration::from_millis(125);
+    loop {
+        if try_join_all(clients.iter().map(|client| client.query_status(query_id)))
+            .await
+            .unwrap()
+            .into_iter()
+            .all(|status| status == QueryStatus::Completed)
+        {
+            break;
+        }
+
+        sleep(delay).await;
+        delay = min(Duration::from_secs(5), delay * 2);
+        // TODO: Add a timeout of some sort. Possibly, add some sort of progress indicator to
+        // the status API so we can check whether the query is making progress.
+    }
+
+    // wait until helpers have processed the query and get the results from them
+    let results: [_; 3] = try_join_all(clients.iter().map(|client| client.query_results(query_id)))
+        .await
+        .unwrap()
+        .try_into()
+        .unwrap();
+
+    let mut results: Vec<F> = results
+        .map(|bytes| AdditiveShare::<F>::from_byte_slice(&bytes).collect::<Vec<_>>())
+        .reconstruct();
+
+    let _ = results.split_off(query_config.max_breakdown_key.try_into().unwrap());
+
+    let lat = mpc_time.elapsed();
+    tracing::info!("Running IPA for {query_size:?} records took {t:?}", t = lat);
+    let mut breakdowns = vec![0; usize::try_from(query_config.max_breakdown_key).unwrap()];
+    for (breakdown_key, trigger_value) in results.into_iter().enumerate() {
+        breakdowns[breakdown_key] += u32::try_from(trigger_value.as_u128()).unwrap();
+    }
+
+    IpaQueryResult {
+        input_size: QuerySize::try_from(query_size).unwrap(),
+        config: query_config,
+        latency: lat,
+        breakdowns,
+    }
+}
diff --git a/src/cli/playbook/mod.rs b/src/cli/playbook/mod.rs
index cdc47be00..842c0a1a0 100644
--- a/src/cli/playbook/mod.rs
+++ b/src/cli/playbook/mod.rs
@@ -11,7 +11,8 @@ pub use input::InputSource;
 pub use multiply::secure_mul;
 use tokio::time::sleep;
 
-pub use self::ipa::playbook_ipa;
+pub use self::ipa::{playbook_ipa, playbook_oprf_ipa};
+
 use crate::{
     config::{ClientConfig, NetworkConfig, PeerConfig},
     net::{ClientIdentity, MpcHelperClient},
diff --git a/src/helpers/transport/query.rs b/src/helpers/transport/query.rs
index ab4e0761b..6bb7a9ed9 100644
--- a/src/helpers/transport/query.rs
+++ b/src/helpers/transport/query.rs
@@ -206,6 +206,7 @@ pub enum QueryType {
     MaliciousIpa(IpaQueryConfig),
     SemiHonestSparseAggregate(SparseAggregateQueryConfig),
     MaliciousSparseAggregate(SparseAggregateQueryConfig),
+    OprfIpa(IpaQueryConfig),
 }
 
 impl QueryType {
@@ -214,6 +215,7 @@ impl QueryType {
     pub const MALICIOUS_IPA_STR: &'static str = "malicious-ipa";
     pub const SEMIHONEST_AGGREGATE_STR: &'static str = "semihonest-sparse-aggregate";
     pub const MALICIOUS_AGGREGATE_STR: &'static str = "malicious-sparse-aggregate";
+    pub const OPRF_IPA_STR: &'static str = "oprf_ipa";
 }
 
 /// TODO: should this `AsRef` impl (used for `Substep`) take into account config of IPA?
@@ -226,6 +228,7 @@ impl AsRef<str> for QueryType {
             QueryType::MaliciousIpa(_) => Self::MALICIOUS_IPA_STR,
             QueryType::SemiHonestSparseAggregate(_) => Self::SEMIHONEST_AGGREGATE_STR,
             QueryType::MaliciousSparseAggregate(_) => Self::MALICIOUS_AGGREGATE_STR,
+            QueryType::OprfIpa(_) => Self::OPRF_IPA_STR,
         }
     }
 }
diff --git a/src/net/http_serde.rs b/src/net/http_serde.rs
index faa2ec13d..406ec9a48 100644
--- a/src/net/http_serde.rs
+++ b/src/net/http_serde.rs
@@ -139,6 +139,10 @@ pub mod query {
                     let Query(q) = req.extract().await?;
                     Ok(QueryType::MaliciousSparseAggregate(q))
                 }
+                QueryType::OPRF_IPA_STR => {
+                    let Query(q) = req.extract().await?;
+                    Ok(QueryType::OprfIpa(q))
+                }
                 other => Err(Error::bad_query_value("query_type", other)),
             }?;
             Ok(QueryConfigQueryParams(QueryConfig {
@@ -161,7 +165,9 @@ pub mod query {
             match self.query_type {
                 #[cfg(any(test, feature = "test-fixture", feature = "cli"))]
                 QueryType::TestMultiply => Ok(()),
-                QueryType::SemiHonestIpa(config) | QueryType::MaliciousIpa(config) => {
+                QueryType::SemiHonestIpa(config)
+                | QueryType::MaliciousIpa(config)
+                | QueryType::OprfIpa(config) => {
                     write!(
                         f,
                         "&per_user_credit_cap={}&max_breakdown_key={}&num_multi_bits={}",
diff --git a/src/query/executor.rs b/src/query/executor.rs
index d99e6df4f..210bf2a61 100644
--- a/src/query/executor.rs
+++ b/src/query/executor.rs
@@ -5,6 +5,7 @@ use std::{
     sync::Arc,
 };
 
+use super::runner::OprfIpaQuery;
 use ::tokio::sync::oneshot;
 use futures::FutureExt;
 use generic_array::GenericArray;
@@ -202,6 +203,33 @@ pub fn execute(
                 },
             )
         }
+        (QueryType::OprfIpa(ipa_config), FieldType::Fp32BitPrime) => do_query(
+            config,
+            gateway,
+            input,
+            move |prss, gateway, config, input| {
+                let ctx = SemiHonestContext::new(prss, gateway);
+                Box::pin(
+                    OprfIpaQuery::<_, Fp32BitPrime>::new(ipa_config)
+                        .execute(ctx, config.size, input)
+                        .then(|res| ready(res.map(|out| Box::new(out) as Box<dyn Result>))),
+                )
+            },
+        ),
+        #[cfg(any(test, feature = "weak-field"))]
+        (QueryType::OprfIpa(ipa_config), FieldType::Fp31) => do_query(
+            config,
+            gateway,
+            input,
+            move |prss, gateway, config, input| {
+                let ctx = SemiHonestContext::new(prss, gateway);
+                Box::pin(
+                    OprfIpaQuery::<_, Fp32BitPrime>::new(ipa_config)
+                        .execute(ctx, config.size, input)
+                        .then(|res| ready(res.map(|out| Box::new(out) as Box<dyn Result>))),
+                )
+            },
+        ),
     }
 }
 
diff --git a/src/query/runner/mod.rs b/src/query/runner/mod.rs
index bcba34275..d9eb28f8f 100644
--- a/src/query/runner/mod.rs
+++ b/src/query/runner/mod.rs
@@ -1,12 +1,14 @@
 mod aggregate;
 mod ipa;
+mod oprf_ipa;
+
 #[cfg(any(test, feature = "cli", feature = "test-fixture"))]
 mod test_multiply;
 
 #[cfg(any(test, feature = "cli", feature = "test-fixture"))]
 pub(super) use test_multiply::execute_test_multiply;
 
-pub(super) use self::{aggregate::SparseAggregateQuery, ipa::IpaQuery};
+pub(super) use self::{aggregate::SparseAggregateQuery, ipa::IpaQuery, oprf_ipa::OprfIpaQuery};
 use crate::{error::Error, query::ProtocolResult};
 
 pub(super) type QueryResult = Result<Box<dyn ProtocolResult>, Error>;
diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
new file mode 100644
index 000000000..94d7ff0ec
--- /dev/null
+++ b/src/query/runner/oprf_ipa.rs
@@ -0,0 +1,127 @@
+use std::marker::PhantomData;
+
+use futures::{Stream, TryStreamExt};
+
+use crate::{
+    error::Error,
+    ff::{Field, Gf2, PrimeField, Serializable},
+    helpers::{
+        query::{IpaQueryConfig, QuerySize},
+        BodyStream, RecordsStream,
+    },
+    protocol::{
+        basics::ShareKnownValue,
+        context::{UpgradableContext, UpgradedContext},
+        prf_sharding::{attribution_and_capping_and_aggregation, PrfShardedIpaInputRow},
+        BreakdownKey, Timestamp, TriggerValue,
+    },
+    report::{EventType, OprfReport},
+    secret_sharing::{
+        replicated::{malicious::ExtendableField, semi_honest::AdditiveShare as Replicated},
+        SharedValue,
+    },
+};
+
+pub struct OprfIpaQuery<C, F> {
+    config: IpaQueryConfig,
+    phantom_data: PhantomData<(C, F)>,
+}
+
+impl<C, F> OprfIpaQuery<C, F> {
+    pub fn new(config: IpaQueryConfig) -> Self {
+        Self {
+            config,
+            phantom_data: PhantomData,
+        }
+    }
+}
+
+impl<C, F> OprfIpaQuery<C, F>
+where
+    C: UpgradableContext,
+    C::UpgradedContext<F>: UpgradedContext<F, Share = Replicated<F>>,
+    C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+    F: PrimeField + ExtendableField,
+    Replicated<F>: Serializable + ShareKnownValue<C, F>,
+    Replicated<Gf2>: Serializable + ShareKnownValue<C, Gf2>,
+{
+    #[tracing::instrument("oprf_ipa_query", skip_all, fields(sz=%query_size))]
+    pub async fn execute<'a>(
+        self,
+        ctx: C,
+        query_size: QuerySize,
+        input_stream: BodyStream,
+    ) -> Result<Vec<Replicated<F>>, Error> {
+        let Self {
+            config,
+            phantom_data: _,
+        } = self;
+        tracing::info!("New query: {config:?}");
+        let sz = usize::from(query_size);
+
+        let input = if config.plaintext_match_keys {
+            let mut v = assert_stream_send(RecordsStream::<
+                OprfReport<Timestamp, BreakdownKey, TriggerValue>,
+                _,
+            >::new(input_stream))
+            .try_concat()
+            .await?;
+            v.truncate(sz);
+            v
+        } else {
+            panic!();
+        };
+
+        // TODO: Compute OPRFs and shuffle and add dummies and stuff (Daniel's code will be called here)
+        let sharded_input = input
+            .into_iter()
+            .map(|single_row| {
+                let is_trigger_bit_share = if single_row.event_type == EventType::Trigger {
+                    Replicated::share_known_value(&ctx, Gf2::ONE)
+                } else {
+                    Replicated::share_known_value(&ctx, Gf2::ZERO)
+                };
+                PrfShardedIpaInputRow {
+                    prf_of_match_key: single_row.mk_oprf,
+                    is_trigger_bit: is_trigger_bit_share,
+                    breakdown_key: single_row.breakdown_key,
+                    trigger_value: single_row.trigger_value,
+                    timestamp: single_row.timestamp,
+                }
+            })
+            .collect::<Vec<_>>();
+        // Until then, we convert the output to something next function is happy about.
+
+        let user_cap: i32 = config.per_user_credit_cap.try_into().unwrap();
+        assert!(
+            user_cap & (user_cap - 1) == 0,
+            "This code only works for a user cap which is a power of 2"
+        );
+
+        attribution_and_capping_and_aggregation::<
+            C,
+            BreakdownKey,
+            TriggerValue,
+            Timestamp,
+            F,
+            _,
+            Replicated<Gf2>,
+        >(
+            ctx,
+            sharded_input,
+            user_cap.ilog2().try_into().unwrap(),
+            config.attribution_window_seconds,
+        )
+        .await
+    }
+}
+
+/// Helps to convince the compiler that things are `Send`. Like `seq_join::assert_send`, but for
+/// streams.
+///
+/// <https://github.com/rust-lang/rust/issues/102211#issuecomment-1367900125>
+pub fn assert_stream_send<'a, T>(
+    st: impl Stream<Item = T> + Send + 'a,
+) -> impl Stream<Item = T> + Send + 'a {
+    st
+}
diff --git a/src/report.rs b/src/report.rs
index 2b9cf1039..fc1686c70 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -1,14 +1,15 @@
 use std::{
     fmt::{Display, Formatter},
     marker::PhantomData,
-    ops::Deref,
+    mem::size_of,
+    ops::{Add, Deref},
 };
 
 use bytes::{BufMut, Bytes};
-use generic_array::GenericArray;
+use generic_array::{ArrayLength, GenericArray};
 use hpke::Serializable as _;
 use rand_core::{CryptoRng, RngCore};
-use typenum::Unsigned;
+use typenum::{Unsigned, U8};
 
 use crate::{
     ff::{GaloisField, Gf40Bit, Gf8Bit, PrimeField, Serializable},
@@ -400,6 +401,93 @@ where
     pub trigger_value: Replicated<TV>,
 }
 
+impl Serializable for u64 {
+    type Size = U8;
+
+    fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
+        let raw = &self.to_le_bytes()[..buf.len()];
+        buf.copy_from_slice(raw);
+    }
+
+    fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
+        let mut buf_to = [0u8; 8];
+        buf_to[..buf.len()].copy_from_slice(buf);
+        u64::from_le_bytes(buf_to)
+    }
+}
+
+impl<TS: GaloisField, BK: GaloisField, TV: GaloisField> Serializable for OprfReport<TS, BK, TV>
+where
+    Replicated<TS>: Serializable,
+    Replicated<BK>: Serializable,
+    Replicated<TV>: Serializable,
+    <Replicated<BK> as Serializable>::Size: Add<U8>,
+    <Replicated<TS> as Serializable>::Size:
+        Add<<<Replicated<BK> as Serializable>::Size as Add<U8>>::Output>,
+    <Replicated<TV> as Serializable>::Size: Add<
+        <<Replicated<TS> as Serializable>::Size as Add<
+            <<Replicated<BK> as Serializable>::Size as Add<U8>>::Output,
+        >>::Output,
+    >,
+    <<Replicated<TV> as Serializable>::Size as Add<
+        <<Replicated<TS> as Serializable>::Size as Add<
+            <<Replicated<BK> as Serializable>::Size as Add<U8>>::Output,
+        >>::Output,
+    >>::Output: ArrayLength,
+{
+    type Size = <<Replicated<TV> as Serializable>::Size as Add<
+        <<Replicated<TS> as Serializable>::Size as Add<
+            <<Replicated<BK> as Serializable>::Size as Add<U8>>::Output,
+        >>::Output,
+    >>::Output;
+    fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
+        let sizeof_u64 = size_of::<u64>();
+        let ts_sz = <Replicated<TS> as Serializable>::Size::USIZE;
+        let bk_sz = <Replicated<BK> as Serializable>::Size::USIZE;
+        let tv_sz = <Replicated<TV> as Serializable>::Size::USIZE;
+
+        self.mk_oprf
+            .serialize(GenericArray::from_mut_slice(&mut buf[..sizeof_u64]));
+
+        self.timestamp.serialize(GenericArray::from_mut_slice(
+            &mut buf[sizeof_u64..sizeof_u64 + ts_sz],
+        ));
+
+        self.breakdown_key.serialize(GenericArray::from_mut_slice(
+            &mut buf[sizeof_u64 + ts_sz..sizeof_u64 + ts_sz + bk_sz],
+        ));
+
+        self.trigger_value.serialize(GenericArray::from_mut_slice(
+            &mut buf[sizeof_u64 + ts_sz + bk_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz],
+        ));
+    }
+
+    fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
+        let sizeof_u64 = size_of::<u64>();
+        let ts_sz = <Replicated<TS> as Serializable>::Size::USIZE;
+        let bk_sz = <Replicated<BK> as Serializable>::Size::USIZE;
+        let tv_sz = <Replicated<TV> as Serializable>::Size::USIZE;
+
+        let mk_oprf = u64::deserialize(GenericArray::from_slice(&buf[..sizeof_u64]));
+        let timestamp = Replicated::<TS>::deserialize(GenericArray::from_slice(
+            &buf[sizeof_u64..sizeof_u64 + ts_sz],
+        ));
+        let breakdown_key = Replicated::<BK>::deserialize(GenericArray::from_slice(
+            &buf[sizeof_u64 + ts_sz..sizeof_u64 + ts_sz + bk_sz],
+        ));
+        let trigger_value = Replicated::<TV>::deserialize(GenericArray::from_slice(
+            &buf[sizeof_u64 + ts_sz + bk_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz],
+        ));
+        Self {
+            timestamp,
+            breakdown_key,
+            trigger_value,
+            event_type: EventType::Source,
+            mk_oprf,
+        }
+    }
+}
+
 #[cfg(all(test, unit_test))]
 mod test {
     use rand::{distributions::Alphanumeric, rngs::StdRng, Rng};

From 73468dc85448b589cd7c7477d3d51c4703ec9f08 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Fri, 27 Oct 2023 17:45:31 +0800
Subject: [PATCH 070/105] Adding EventType in serialization and deserialization

---
 src/protocol/prf_sharding/mod.rs |  2 ++
 src/report.rs                    | 50 +++++++++++++++++++++++++++-----
 2 files changed, 45 insertions(+), 7 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 87832f797..7f8fa56bb 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -728,6 +728,7 @@ where
     let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
     let prime_field_m_ctx = prime_field_validator.context();
 
+    println!("attribution_and_capping starting");
     let user_level_attributions: Vec<CappedAttributionOutputs> = attribution_and_capping(
         sh_ctx,
         input_rows,
@@ -736,6 +737,7 @@ where
     )
     .await?;
 
+    println!("do_aggregation starting");
     do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
 }
 
diff --git a/src/report.rs b/src/report.rs
index fc1686c70..8af5fb41a 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -9,7 +9,7 @@ use bytes::{BufMut, Bytes};
 use generic_array::{ArrayLength, GenericArray};
 use hpke::Serializable as _;
 use rand_core::{CryptoRng, RngCore};
-use typenum::{Unsigned, U8};
+use typenum::{Unsigned, U8, U9, U1};
 
 use crate::{
     ff::{GaloisField, Gf40Bit, Gf8Bit, PrimeField, Serializable},
@@ -48,6 +48,31 @@ pub enum EventType {
     Source,
 }
 
+impl Serializable for EventType {
+    type Size = U1;
+
+    fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
+
+        let raw: &[u8] = match self {
+            EventType::Trigger => &[0],
+            EventType::Source => &[1],
+        };
+        buf.copy_from_slice(raw);
+    }
+
+    fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
+
+        let mut buf_to = [0u8; 1];
+        buf_to[..buf.len()].copy_from_slice(buf);
+        
+        match buf[0] {
+            0 => EventType::Trigger,
+            1 => EventType::Source,
+            2_u8..=u8::MAX => panic!("Unreachable code"),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct ParseEventTypeError(u8);
 
@@ -421,27 +446,29 @@ where
     Replicated<TS>: Serializable,
     Replicated<BK>: Serializable,
     Replicated<TV>: Serializable,
-    <Replicated<BK> as Serializable>::Size: Add<U8>,
+    <Replicated<BK> as Serializable>::Size: Add<U9>,
     <Replicated<TS> as Serializable>::Size:
-        Add<<<Replicated<BK> as Serializable>::Size as Add<U8>>::Output>,
+        Add<<<Replicated<BK> as Serializable>::Size as Add<U9>>::Output>,
     <Replicated<TV> as Serializable>::Size: Add<
         <<Replicated<TS> as Serializable>::Size as Add<
-            <<Replicated<BK> as Serializable>::Size as Add<U8>>::Output,
+            <<Replicated<BK> as Serializable>::Size as Add<U9>>::Output,
         >>::Output,
     >,
     <<Replicated<TV> as Serializable>::Size as Add<
         <<Replicated<TS> as Serializable>::Size as Add<
-            <<Replicated<BK> as Serializable>::Size as Add<U8>>::Output,
+            <<Replicated<BK> as Serializable>::Size as Add<U9>>::Output,
         >>::Output,
     >>::Output: ArrayLength,
 {
     type Size = <<Replicated<TV> as Serializable>::Size as Add<
         <<Replicated<TS> as Serializable>::Size as Add<
-            <<Replicated<BK> as Serializable>::Size as Add<U8>>::Output,
+            <<Replicated<BK> as Serializable>::Size as Add<U9>>::Output,
         >>::Output,
     >>::Output;
+
     fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
         let sizeof_u64 = size_of::<u64>();
+        let sizeof_eventtype = size_of::<EventType>();
         let ts_sz = <Replicated<TS> as Serializable>::Size::USIZE;
         let bk_sz = <Replicated<BK> as Serializable>::Size::USIZE;
         let tv_sz = <Replicated<TV> as Serializable>::Size::USIZE;
@@ -460,10 +487,16 @@ where
         self.trigger_value.serialize(GenericArray::from_mut_slice(
             &mut buf[sizeof_u64 + ts_sz + bk_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz],
         ));
+
+        self.event_type.serialize(GenericArray::from_mut_slice(
+            &mut buf[sizeof_u64 + ts_sz + bk_sz + tv_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz + sizeof_eventtype],
+        ));
     }
 
     fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
         let sizeof_u64 = size_of::<u64>();
+        let sizeof_eventtype = size_of::<EventType>();
+
         let ts_sz = <Replicated<TS> as Serializable>::Size::USIZE;
         let bk_sz = <Replicated<BK> as Serializable>::Size::USIZE;
         let tv_sz = <Replicated<TV> as Serializable>::Size::USIZE;
@@ -478,11 +511,14 @@ where
         let trigger_value = Replicated::<TV>::deserialize(GenericArray::from_slice(
             &buf[sizeof_u64 + ts_sz + bk_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz],
         ));
+        let event_type = EventType::deserialize(GenericArray::from_slice(
+            &buf[sizeof_u64 + ts_sz + bk_sz + tv_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz + sizeof_eventtype],
+        ));
         Self {
             timestamp,
             breakdown_key,
             trigger_value,
-            event_type: EventType::Source,
+            event_type,
             mk_oprf,
         }
     }

From f77a8b44c6facdc336d0ba0d8b0b55fc533092b0 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Mon, 30 Oct 2023 17:11:16 +0800
Subject: [PATCH 071/105] Incorporate feedback

---
 src/bin/report_collector.rs | 61 ++++++++++++++++++++-----------------
 src/report.rs               | 12 ++++----
 src/test_fixture/ipa.rs     |  5 +++
 3 files changed, 44 insertions(+), 34 deletions(-)

diff --git a/src/bin/report_collector.rs b/src/bin/report_collector.rs
index 89b80bb0e..f8ba75d7e 100644
--- a/src/bin/report_collector.rs
+++ b/src/bin/report_collector.rs
@@ -26,7 +26,7 @@ use ipa::{
     protocol::{BreakdownKey, MatchKey},
     report::{KeyIdentifier, DEFAULT_KEY_ID},
     test_fixture::{
-        ipa::{ipa_in_the_clear, CappingOrder, IpaSecurityModel, TestRawDataRecord},
+        ipa::{ipa_in_the_clear, CappingOrder, IpaQueryStyle, IpaSecurityModel, TestRawDataRecord},
         EventGenerator, EventGeneratorConfig,
     },
 };
@@ -136,7 +136,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 IpaSecurityModel::SemiHonest,
                 config,
                 &clients,
-                false,
+                IpaQueryStyle::SortInMpc,
             )
             .await?
         }
@@ -147,7 +147,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 IpaSecurityModel::Malicious,
                 config,
                 &clients,
-                false,
+                IpaQueryStyle::SortInMpc,
             )
             .await?
         }
@@ -164,7 +164,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 IpaSecurityModel::SemiHonest,
                 config,
                 &clients,
-                true,
+                IpaQueryStyle::Oprf,
             )
             .await?
         }
@@ -236,31 +236,25 @@ async fn ipa(
     security_model: IpaSecurityModel,
     ipa_query_config: IpaQueryConfig,
     helper_clients: &[MpcHelperClient; 3],
-    oprf_algorithm: bool,
+    query_style: IpaQueryStyle,
 ) -> Result<(), Box<dyn Error>> {
     let input = InputSource::from(&args.input);
     let query_type: QueryType;
-    match (security_model, oprf_algorithm) {
-        (IpaSecurityModel::SemiHonest, false) => {
+    match (security_model, &query_style) {
+        (IpaSecurityModel::SemiHonest, IpaQueryStyle::SortInMpc) => {
             query_type = QueryType::SemiHonestIpa(ipa_query_config.clone());
         }
-        (IpaSecurityModel::Malicious, false) => {
+        (IpaSecurityModel::Malicious, IpaQueryStyle::SortInMpc) => {
             query_type = QueryType::MaliciousIpa(ipa_query_config.clone())
         }
-        (IpaSecurityModel::SemiHonest, true) => {
+        (IpaSecurityModel::SemiHonest, IpaQueryStyle::Oprf) => {
             query_type = QueryType::OprfIpa(ipa_query_config.clone());
         }
-        (IpaSecurityModel::Malicious, true) => {
+        (IpaSecurityModel::Malicious, IpaQueryStyle::Oprf) => {
             panic!("OPRF for malicious is not implemented as yet")
         }
     };
 
-    let order = if oprf_algorithm {
-        CappingOrder::CapMostRecentFirst
-    } else {
-        CappingOrder::CapOldestFirst
-    };
-
     let input_rows = input.iter::<TestRawDataRecord>().collect::<Vec<_>>();
     let query_config = QueryConfig {
         size: QuerySize::try_from(input_rows.len()).unwrap(),
@@ -275,7 +269,10 @@ async fn ipa(
             ipa_query_config.per_user_credit_cap,
             ipa_query_config.attribution_window_seconds,
             ipa_query_config.max_breakdown_key,
-            &order,
+            &(match query_style {
+                IpaQueryStyle::Oprf => CappingOrder::CapMostRecentFirst,
+                IpaQueryStyle::SortInMpc => CappingOrder::CapOldestFirst,
+            }),
         );
 
         // pad the output vector to the max breakdown key, to make sure it is aligned with the MPC results
@@ -288,18 +285,26 @@ async fn ipa(
     };
 
     let mut key_registries = KeyRegistries::default();
-    let actual = if oprf_algorithm {
-        playbook_oprf_ipa::<Fp32BitPrime>(input_rows, &helper_clients, query_id, ipa_query_config)
+    let actual = match query_style {
+        IpaQueryStyle::Oprf => {
+            playbook_oprf_ipa::<Fp32BitPrime>(
+                input_rows,
+                &helper_clients,
+                query_id,
+                ipa_query_config,
+            )
             .await
-    } else {
-        playbook_ipa::<Fp32BitPrime, MatchKey, BreakdownKey, _>(
-            &input_rows,
-            &helper_clients,
-            query_id,
-            ipa_query_config,
-            key_registries.init_from(network),
-        )
-        .await
+        }
+        IpaQueryStyle::SortInMpc => {
+            playbook_ipa::<Fp32BitPrime, MatchKey, BreakdownKey, _>(
+                &input_rows,
+                &helper_clients,
+                query_id,
+                ipa_query_config,
+                key_registries.init_from(network),
+            )
+            .await
+        }
     };
 
     if let Some(ref path) = args.output_file {
diff --git a/src/report.rs b/src/report.rs
index 8af5fb41a..01d28deff 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -9,7 +9,7 @@ use bytes::{BufMut, Bytes};
 use generic_array::{ArrayLength, GenericArray};
 use hpke::Serializable as _;
 use rand_core::{CryptoRng, RngCore};
-use typenum::{Unsigned, U8, U9, U1};
+use typenum::{Unsigned, U1, U8, U9};
 
 use crate::{
     ff::{GaloisField, Gf40Bit, Gf8Bit, PrimeField, Serializable},
@@ -52,7 +52,6 @@ impl Serializable for EventType {
     type Size = U1;
 
     fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
-
         let raw: &[u8] = match self {
             EventType::Trigger => &[0],
             EventType::Source => &[1],
@@ -61,10 +60,9 @@ impl Serializable for EventType {
     }
 
     fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
-
         let mut buf_to = [0u8; 1];
         buf_to[..buf.len()].copy_from_slice(buf);
-        
+
         match buf[0] {
             0 => EventType::Trigger,
             1 => EventType::Source,
@@ -489,7 +487,8 @@ where
         ));
 
         self.event_type.serialize(GenericArray::from_mut_slice(
-            &mut buf[sizeof_u64 + ts_sz + bk_sz + tv_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz + sizeof_eventtype],
+            &mut buf[sizeof_u64 + ts_sz + bk_sz + tv_sz
+                ..sizeof_u64 + ts_sz + bk_sz + tv_sz + sizeof_eventtype],
         ));
     }
 
@@ -512,7 +511,8 @@ where
             &buf[sizeof_u64 + ts_sz + bk_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz],
         ));
         let event_type = EventType::deserialize(GenericArray::from_slice(
-            &buf[sizeof_u64 + ts_sz + bk_sz + tv_sz..sizeof_u64 + ts_sz + bk_sz + tv_sz + sizeof_eventtype],
+            &buf[sizeof_u64 + ts_sz + bk_sz + tv_sz
+                ..sizeof_u64 + ts_sz + bk_sz + tv_sz + sizeof_eventtype],
         ));
         Self {
             timestamp,
diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index a33b92e5b..e6f899b79 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -24,6 +24,11 @@ pub enum IpaSecurityModel {
     Malicious,
 }
 
+pub enum IpaQueryStyle {
+    SortInMpc,
+    Oprf,
+}
+
 #[derive(Debug, Clone)]
 pub struct TestRawDataRecord {
     pub timestamp: u64,

From 4d2469e78fa6d8596ab529daf3f93ac467e36244 Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Mon, 30 Oct 2023 17:14:49 +0800
Subject: [PATCH 072/105] Make clippy happy

---
 output.txt                       | 21 ++++++++
 src/cli/playbook/ipa.rs          | 92 +++++++++++---------------------
 src/cli/playbook/mod.rs          |  1 -
 src/protocol/prf_sharding/mod.rs |  2 -
 src/query/executor.rs            |  2 +-
 src/query/runner/aggregate.rs    |  8 ++-
 src/query/runner/ipa.rs          | 29 +++-------
 src/query/runner/oprf_ipa.rs     | 21 ++------
 src/report.rs                    |  4 +-
 9 files changed, 70 insertions(+), 110 deletions(-)
 create mode 100644 output.txt

diff --git a/output.txt b/output.txt
new file mode 100644
index 000000000..77fb36b55
--- /dev/null
+++ b/output.txt
@@ -0,0 +1,21 @@
+{
+  "input_size": 3,
+  "config": {
+    "per_user_credit_cap": 16,
+    "max_breakdown_key": 8,
+    "attribution_window_seconds": null,
+    "num_multi_bits": 3,
+    "plaintext_match_keys": true
+  },
+  "latency": 1.8909392980000002,
+  "breakdowns": [
+    48,
+    67,
+    54,
+    64,
+    54,
+    78,
+    74,
+    61
+  ]
+}
\ No newline at end of file
diff --git a/src/cli/playbook/ipa.rs b/src/cli/playbook/ipa.rs
index c509cb400..1f672d75c 100644
--- a/src/cli/playbook/ipa.rs
+++ b/src/cli/playbook/ipa.rs
@@ -99,64 +99,8 @@ where
 
     let inputs = buffers.map(BodyStream::from);
     tracing::info!("Starting query after finishing encryption");
-    let mpc_time = Instant::now();
-    try_join_all(
-        inputs
-            .into_iter()
-            .zip(clients)
-            .map(|(input_stream, client)| {
-                client.query_input(QueryInput {
-                    query_id,
-                    input_stream,
-                })
-            }),
-    )
-    .await
-    .unwrap();
 
-    let mut delay = Duration::from_millis(125);
-    loop {
-        if try_join_all(clients.iter().map(|client| client.query_status(query_id)))
-            .await
-            .unwrap()
-            .into_iter()
-            .all(|status| status == QueryStatus::Completed)
-        {
-            break;
-        }
-
-        sleep(delay).await;
-        delay = min(Duration::from_secs(5), delay * 2);
-        // TODO: Add a timeout of some sort. Possibly, add some sort of progress indicator to
-        // the status API so we can check whether the query is making progress.
-    }
-
-    // wait until helpers have processed the query and get the results from them
-    let results: [_; 3] = try_join_all(clients.iter().map(|client| client.query_results(query_id)))
-        .await
-        .unwrap()
-        .try_into()
-        .unwrap();
-
-    let results: Vec<F> = results
-        .map(|bytes| AdditiveShare::<F>::from_byte_slice(&bytes).collect::<Vec<_>>())
-        .reconstruct();
-
-    let lat = mpc_time.elapsed();
-    tracing::info!("Running IPA for {query_size:?} records took {t:?}", t = lat);
-    let mut breakdowns = vec![0; usize::try_from(query_config.max_breakdown_key).unwrap()];
-    for (breakdown_key, trigger_value) in results.into_iter().enumerate() {
-        // TODO: make the data type used consistent with `ipa_in_the_clear`
-        // I think using u32 is wrong, we should move to u128
-        breakdowns[breakdown_key] += u32::try_from(trigger_value.as_u128()).unwrap();
-    }
-
-    IpaQueryResult {
-        input_size: QuerySize::try_from(query_size).unwrap(),
-        config: query_config,
-        latency: lat,
-        breakdowns,
-    }
+    do_processing::<F>(inputs, clients, query_id, query_config).await
 }
 
 pub async fn playbook_oprf_ipa<F>(
@@ -177,7 +121,8 @@ where
         buffer.resize(query_size * sz, 0u8);
     }
 
-    //TODO(richaj) This manual sorting will be removed once we have the PRF sharding in place
+    //TODO(richaj) This manual sorting will be removed once we have the PRF sharding in place.
+    //This does a stable sort. It also expects the inputs to be sorted by timestamp
     records.sort_by(|a, b| b.user_id.cmp(&a.user_id));
 
     let shares: [Vec<OprfReport<Timestamp, BreakdownKey, TriggerValue>>; 3] =
@@ -190,6 +135,21 @@ where
 
     let inputs = buffers.map(BodyStream::from);
     tracing::info!("Starting query for OPRF");
+
+    do_processing::<F>(inputs, clients, query_id, query_config).await
+}
+
+pub async fn do_processing<F>(
+    inputs: [BodyStream; 3],
+    clients: &[MpcHelperClient; 3],
+    query_id: QueryId,
+    query_config: IpaQueryConfig,
+) -> IpaQueryResult
+where
+    F: PrimeField,
+    AdditiveShare<F>: Serializable,
+{
+    let query_size = inputs.len();
     let mpc_time = Instant::now();
     try_join_all(
         inputs
@@ -229,17 +189,25 @@ where
         .try_into()
         .unwrap();
 
-    let mut results: Vec<F> = results
+    let results: Vec<F> = results
         .map(|bytes| AdditiveShare::<F>::from_byte_slice(&bytes).collect::<Vec<_>>())
         .reconstruct();
 
-    let _ = results.split_off(query_config.max_breakdown_key.try_into().unwrap());
-
     let lat = mpc_time.elapsed();
+
     tracing::info!("Running IPA for {query_size:?} records took {t:?}", t = lat);
     let mut breakdowns = vec![0; usize::try_from(query_config.max_breakdown_key).unwrap()];
     for (breakdown_key, trigger_value) in results.into_iter().enumerate() {
-        breakdowns[breakdown_key] += u32::try_from(trigger_value.as_u128()).unwrap();
+        // TODO: make the data type used consistent with `ipa_in_the_clear`
+        // I think using u32 is wrong, we should move to u128
+        assert!(
+            breakdown_key < query_config.max_breakdown_key.try_into().unwrap()
+                || trigger_value == F::ZERO,
+            "trigger values were attributed to buckets more than max breakdown key"
+        );
+        if breakdown_key < query_config.max_breakdown_key.try_into().unwrap() {
+            breakdowns[breakdown_key] += u32::try_from(trigger_value.as_u128()).unwrap();
+        }
     }
 
     IpaQueryResult {
diff --git a/src/cli/playbook/mod.rs b/src/cli/playbook/mod.rs
index 842c0a1a0..4fe0ac6ca 100644
--- a/src/cli/playbook/mod.rs
+++ b/src/cli/playbook/mod.rs
@@ -12,7 +12,6 @@ pub use multiply::secure_mul;
 use tokio::time::sleep;
 
 pub use self::ipa::{playbook_ipa, playbook_oprf_ipa};
-
 use crate::{
     config::{ClientConfig, NetworkConfig, PeerConfig},
     net::{ClientIdentity, MpcHelperClient},
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 7f8fa56bb..87832f797 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -728,7 +728,6 @@ where
     let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
     let prime_field_m_ctx = prime_field_validator.context();
 
-    println!("attribution_and_capping starting");
     let user_level_attributions: Vec<CappedAttributionOutputs> = attribution_and_capping(
         sh_ctx,
         input_rows,
@@ -737,7 +736,6 @@ where
     )
     .await?;
 
-    println!("do_aggregation starting");
     do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
 }
 
diff --git a/src/query/executor.rs b/src/query/executor.rs
index 210bf2a61..4da5f7a6c 100644
--- a/src/query/executor.rs
+++ b/src/query/executor.rs
@@ -5,7 +5,6 @@ use std::{
     sync::Arc,
 };
 
-use super::runner::OprfIpaQuery;
 use ::tokio::sync::oneshot;
 use futures::FutureExt;
 use generic_array::GenericArray;
@@ -15,6 +14,7 @@ use rand_core::SeedableRng;
 use shuttle::future as tokio;
 use typenum::Unsigned;
 
+use super::runner::OprfIpaQuery;
 #[cfg(any(test, feature = "cli", feature = "test-fixture"))]
 use crate::query::runner::execute_test_multiply;
 use crate::{
diff --git a/src/query/runner/aggregate.rs b/src/query/runner/aggregate.rs
index e0dee3550..23cd6e7ba 100644
--- a/src/query/runner/aggregate.rs
+++ b/src/query/runner/aggregate.rs
@@ -2,7 +2,6 @@ use std::marker::PhantomData;
 
 use futures_util::TryStreamExt;
 
-use super::ipa::assert_stream_send;
 use crate::{
     error::Error,
     ff::{Gf2, Gf8Bit, PrimeField, Serializable},
@@ -83,10 +82,9 @@ where
 
         let input = {
             //TODO: Replace `Gf8Bit` with an appropriate type specified by the config `contribution_bits`
-            let mut v = assert_stream_send(RecordsStream::<
-                SparseAggregateInputRow<Gf8Bit, BreakdownKey>,
-                _,
-            >::new(input_stream))
+            let mut v = RecordsStream::<SparseAggregateInputRow<Gf8Bit, BreakdownKey>, _>::new(
+                input_stream,
+            )
             .try_concat()
             .await?;
             v.truncate(sz);
diff --git a/src/query/runner/ipa.rs b/src/query/runner/ipa.rs
index 2b19ead23..ed4a3da43 100644
--- a/src/query/runner/ipa.rs
+++ b/src/query/runner/ipa.rs
@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use futures::{
     stream::{iter, repeat},
-    Stream, StreamExt, TryStreamExt,
+    StreamExt, TryStreamExt,
 };
 
 use crate::{
@@ -89,19 +89,16 @@ where
         let sz = usize::from(query_size);
 
         let input = if config.plaintext_match_keys {
-            let mut v = assert_stream_send(RecordsStream::<
-                IPAInputRow<F, MatchKey, BreakdownKey>,
-                _,
-            >::new(input_stream))
-            .try_concat()
-            .await?;
+            let mut v =
+                RecordsStream::<IPAInputRow<F, MatchKey, BreakdownKey>, _>::new(input_stream)
+                    .try_concat()
+                    .await?;
             v.truncate(sz);
             v
         } else {
-            assert_stream_send(LengthDelimitedStream::<
-                EncryptedReport<F, MatchKey, BreakdownKey, _>,
-                _,
-            >::new(input_stream))
+            LengthDelimitedStream::<EncryptedReport<F, MatchKey, BreakdownKey, _>, _>::new(
+                input_stream,
+            )
             .map_err(Into::<Error>::into)
             .map_ok(|enc_reports| {
                 iter(enc_reports.into_iter().map(|enc_report| {
@@ -147,16 +144,6 @@ where
     }
 }
 
-/// Helps to convince the compiler that things are `Send`. Like `seq_join::assert_send`, but for
-/// streams.
-///
-/// <https://github.com/rust-lang/rust/issues/102211#issuecomment-1367900125>
-pub fn assert_stream_send<'a, T>(
-    st: impl Stream<Item = T> + Send + 'a,
-) -> impl Stream<Item = T> + Send + 'a {
-    st
-}
-
 /// no dependency on `weak-field` feature because it is enabled in tests by default
 #[cfg(all(test, unit_test))]
 mod tests {
diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
index 94d7ff0ec..e77a0300e 100644
--- a/src/query/runner/oprf_ipa.rs
+++ b/src/query/runner/oprf_ipa.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use futures::{Stream, TryStreamExt};
+use futures::TryStreamExt;
 
 use crate::{
     error::Error,
@@ -60,16 +60,15 @@ where
         let sz = usize::from(query_size);
 
         let input = if config.plaintext_match_keys {
-            let mut v = assert_stream_send(RecordsStream::<
-                OprfReport<Timestamp, BreakdownKey, TriggerValue>,
-                _,
-            >::new(input_stream))
+            let mut v = RecordsStream::<OprfReport<Timestamp, BreakdownKey, TriggerValue>, _>::new(
+                input_stream,
+            )
             .try_concat()
             .await?;
             v.truncate(sz);
             v
         } else {
-            panic!();
+            panic!("Encrypted match key handling is not handled for OPRF flow as yet");
         };
 
         // TODO: Compute OPRFs and shuffle and add dummies and stuff (Daniel's code will be called here)
@@ -115,13 +114,3 @@ where
         .await
     }
 }
-
-/// Helps to convince the compiler that things are `Send`. Like `seq_join::assert_send`, but for
-/// streams.
-///
-/// <https://github.com/rust-lang/rust/issues/102211#issuecomment-1367900125>
-pub fn assert_stream_send<'a, T>(
-    st: impl Stream<Item = T> + Send + 'a,
-) -> impl Stream<Item = T> + Send + 'a {
-    st
-}
diff --git a/src/report.rs b/src/report.rs
index 01d28deff..5c8ada0ae 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -516,10 +516,10 @@ where
         ));
         Self {
             timestamp,
+            mk_oprf,
+            event_type,
             breakdown_key,
             trigger_value,
-            event_type,
-            mk_oprf,
         }
     }
 }

From 0e9f41b43a6568dd6e6a72d1908bffc77895918f Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 31 Oct 2023 11:18:51 +0800
Subject: [PATCH 073/105] More fixes

---
 src/cli/playbook/ipa.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cli/playbook/ipa.rs b/src/cli/playbook/ipa.rs
index 1f672d75c..3c758a6a9 100644
--- a/src/cli/playbook/ipa.rs
+++ b/src/cli/playbook/ipa.rs
@@ -100,7 +100,7 @@ where
     let inputs = buffers.map(BodyStream::from);
     tracing::info!("Starting query after finishing encryption");
 
-    do_processing::<F>(inputs, clients, query_id, query_config).await
+    do_processing::<F>(inputs, query_size, clients, query_id, query_config).await
 }
 
 pub async fn playbook_oprf_ipa<F>(
@@ -136,11 +136,12 @@ where
     let inputs = buffers.map(BodyStream::from);
     tracing::info!("Starting query for OPRF");
 
-    do_processing::<F>(inputs, clients, query_id, query_config).await
+    do_processing::<F>(inputs, query_size, clients, query_id, query_config).await
 }
 
 pub async fn do_processing<F>(
     inputs: [BodyStream; 3],
+    query_size: usize,
     clients: &[MpcHelperClient; 3],
     query_id: QueryId,
     query_config: IpaQueryConfig,
@@ -149,7 +150,6 @@ where
     F: PrimeField,
     AdditiveShare<F>: Serializable,
 {
-    let query_size = inputs.len();
     let mpc_time = Instant::now();
     try_join_all(
         inputs

From 91905cddc5269661247a61b2e8a0cf8d315aa13b Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 31 Oct 2023 11:30:39 +0800
Subject: [PATCH 074/105] Remove output.txt

---
 output.txt | 21 ---------------------
 1 file changed, 21 deletions(-)
 delete mode 100644 output.txt

diff --git a/output.txt b/output.txt
deleted file mode 100644
index 77fb36b55..000000000
--- a/output.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "input_size": 3,
-  "config": {
-    "per_user_credit_cap": 16,
-    "max_breakdown_key": 8,
-    "attribution_window_seconds": null,
-    "num_multi_bits": 3,
-    "plaintext_match_keys": true
-  },
-  "latency": 1.8909392980000002,
-  "breakdowns": [
-    48,
-    67,
-    54,
-    64,
-    54,
-    78,
-    74,
-    61
-  ]
-}
\ No newline at end of file

From 0747a6f773b392309fcc8cccb84e2c46fecf07ba Mon Sep 17 00:00:00 2001
From: Richa Jain <richajain.dce@gmail.com>
Date: Tue, 31 Oct 2023 11:33:51 +0800
Subject: [PATCH 075/105] Rename function

---
 src/cli/playbook/ipa.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cli/playbook/ipa.rs b/src/cli/playbook/ipa.rs
index 3c758a6a9..6c258f858 100644
--- a/src/cli/playbook/ipa.rs
+++ b/src/cli/playbook/ipa.rs
@@ -100,7 +100,7 @@ where
     let inputs = buffers.map(BodyStream::from);
     tracing::info!("Starting query after finishing encryption");
 
-    do_processing::<F>(inputs, query_size, clients, query_id, query_config).await
+    run_query_and_validate::<F>(inputs, query_size, clients, query_id, query_config).await
 }
 
 pub async fn playbook_oprf_ipa<F>(
@@ -136,10 +136,10 @@ where
     let inputs = buffers.map(BodyStream::from);
     tracing::info!("Starting query for OPRF");
 
-    do_processing::<F>(inputs, query_size, clients, query_id, query_config).await
+    run_query_and_validate::<F>(inputs, query_size, clients, query_id, query_config).await
 }
 
-pub async fn do_processing<F>(
+pub async fn run_query_and_validate<F>(
     inputs: [BodyStream; 3],
     query_size: usize,
     clients: &[MpcHelperClient; 3],

From 2b50c45f5775931baec20c3fb440fd1376167c5a Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 31 Oct 2023 15:16:23 -0700
Subject: [PATCH 076/105] Fix OPRF attribution and capping circuit

It was using sequential join that limits number of futures driven concurrently to completion. This circuit requires all user-level circuits to be polled, so `parallel_join` is more appropriate

There may be other places where parallel join must be used, I did not check those, this got me to 10k rows.
---
 src/protocol/prf_sharding/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 87832f797..fcca9ab97 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -29,7 +29,7 @@ use crate::{
         },
         BitDecomposed, Linear as LinearSecretSharing, SharedValue,
     },
-    seq_join::{seq_join, seq_try_join_all},
+    seq_join::seq_join,
 };
 
 pub mod bucket;
@@ -381,7 +381,7 @@ where
             attribution_window_seconds,
         ));
     }
-    let outputs_chunked_by_user = seq_try_join_all(sh_ctx.active_work(), futures).await?;
+    let outputs_chunked_by_user = sh_ctx.parallel_join(futures).await?;
     Ok(outputs_chunked_by_user
         .into_iter()
         .flatten()

From afeb72c05fce1279dc26e6b18c7fd7e03a70e4e9 Mon Sep 17 00:00:00 2001
From: Martin Thomson <mt@lowentropy.net>
Date: Wed, 1 Nov 2023 16:25:13 +1100
Subject: [PATCH 077/105] modulus conversion with retention

If you only want to convert some fields of a struct, this would allow
you to do that.  This is incomplete in the sense that it produces
tuples.  You might want to have a type that can be reconstructed from
the converted and retained fields.  Maybe that could be part of this
functionality also, but I'm leaving that for a future refactoring.
---
 src/ff/galois_field.rs                        |  29 +-
 src/protocol/boolean/generate_random_bits.rs  |  25 +-
 .../modulus_conversion/convert_shares.rs      | 256 ++++++++++++++++--
 src/protocol/modulus_conversion/mod.rs        |   3 +-
 src/protocol/sort/generate_permutation.rs     |   2 +-
 src/protocol/sort/generate_permutation_opt.rs |   2 +-
 6 files changed, 270 insertions(+), 47 deletions(-)

diff --git a/src/ff/galois_field.rs b/src/ff/galois_field.rs
index 0c3814d27..633e1fd72 100644
--- a/src/ff/galois_field.rs
+++ b/src/ff/galois_field.rs
@@ -131,7 +131,7 @@ fn clmul<GF: GaloisField>(a: GF, b: GF) -> u128 {
 }
 
 macro_rules! bit_array_impl {
-    ( $modname:ident, $name:ident, $store:ty, $bits:expr, $one:expr, $polynomial:expr ) => {
+    ( $modname:ident, $name:ident, $store:ty, $bits:expr, $one:expr, $polynomial:expr, $({$($extra:item)*})? ) => {
         #[allow(clippy::suspicious_arithmetic_impl)]
         #[allow(clippy::suspicious_op_assign_impl)]
         mod $modname {
@@ -534,6 +534,8 @@ macro_rules! bit_array_impl {
                     assert_eq!(a, $name::deserialize(&buf));
                 }
             }
+
+            $( $( $extra )* )?
         }
 
         pub use $modname::$name;
@@ -547,7 +549,7 @@ bit_array_impl!(
     40,
     bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
     // x^40 + x^5 + x^3 + x^2 + 1
-    0b1_0000_0000_0000_0000_0000_0000_0000_0000_0010_1101_u128
+    0b1_0000_0000_0000_0000_0000_0000_0000_0000_0010_1101_u128,
 );
 
 bit_array_impl!(
@@ -557,7 +559,7 @@ bit_array_impl!(
     32,
     bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
     // x^32 + x^7 + x^3 + x^2 + 1
-    0b1_0000_0000_0000_0000_0000_0000_1000_1101_u128
+    0b1_0000_0000_0000_0000_0000_0000_1000_1101_u128,
 );
 
 bit_array_impl!(
@@ -567,7 +569,7 @@ bit_array_impl!(
     20,
     bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
     // x^20 + x^7 + x^3 + x^2 + 1
-    0b1000_0000_0000_1000_1101_u128
+    0b1000_0000_0000_1000_1101_u128,
 );
 
 bit_array_impl!(
@@ -577,7 +579,7 @@ bit_array_impl!(
     8,
     bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0),
     // x^8 + x^4 + x^3 + x + 1
-    0b1_0001_1011_u128
+    0b1_0001_1011_u128,
 );
 
 bit_array_impl!(
@@ -587,7 +589,7 @@ bit_array_impl!(
     9,
     bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0, 0, 0, 0, 0),
     // x^9 + x^4 + x^3 + x + 1
-    0b10_0001_1011_u128
+    0b10_0001_1011_u128,
 );
 
 bit_array_impl!(
@@ -597,7 +599,7 @@ bit_array_impl!(
     5,
     bitarr!(const u8, Lsb0; 1, 0, 0, 0, 0),
     // x^5 + x^4 + x^3 + x^2 + x + 1
-    0b111_111_u128
+    0b111_111_u128,
 );
 
 bit_array_impl!(
@@ -607,7 +609,7 @@ bit_array_impl!(
     3,
     bitarr!(const u8, Lsb0; 1, 0, 0),
     // x^3 + x + 1
-    0b1_011_u128
+    0b1_011_u128,
 );
 
 bit_array_impl!(
@@ -617,5 +619,14 @@ bit_array_impl!(
     1,
     bitarr!(const u8, Lsb0; 1),
     // x
-    0b10_u128
+    0b10_u128,
+    {
+        impl From<bool> for Gf2 {
+            fn from(value: bool) -> Self {
+                let mut v = Gf2::ZERO;
+                v.0.set(0, value);
+                v
+            }
+        }
+    }
 );
diff --git a/src/protocol/boolean/generate_random_bits.rs b/src/protocol/boolean/generate_random_bits.rs
index f8e2d2e87..184bf7d80 100644
--- a/src/protocol/boolean/generate_random_bits.rs
+++ b/src/protocol/boolean/generate_random_bits.rs
@@ -5,6 +5,7 @@ use futures::stream::{iter as stream_iter, Stream, StreamExt};
 use crate::{
     error::Error,
     ff::PrimeField,
+    helpers::Role,
     protocol::{
         basics::SecureMul,
         context::{prss::InstrumentedIndexedSharedRandomness, Context, UpgradedContext},
@@ -47,16 +48,14 @@ impl RawRandomBits {
 }
 
 impl ToBitConversionTriples for RawRandomBits {
+    type Residual = ();
+
     // TODO const for this in place of the function
     fn bits(&self) -> u32 {
         self.count
     }
 
-    fn triple<F: PrimeField>(
-        &self,
-        role: crate::helpers::Role,
-        i: u32,
-    ) -> BitConversionTriple<Replicated<F>> {
+    fn triple<F: PrimeField>(&self, role: Role, i: u32) -> BitConversionTriple<Replicated<F>> {
         debug_assert!(u128::BITS - F::PRIME.into().leading_zeros() >= self.count);
         assert!(i < self.count);
         BitConversionTriple::new(
@@ -65,6 +64,21 @@ impl ToBitConversionTriples for RawRandomBits {
             ((self.right >> i) & 1) == 1,
         )
     }
+
+    fn into_triples<F, I>(
+        self,
+        role: Role,
+        indices: I,
+    ) -> (
+        BitDecomposed<BitConversionTriple<Replicated<F>>>,
+        Self::Residual,
+    )
+    where
+        F: PrimeField,
+        I: IntoIterator<Item = u32>,
+    {
+        (self.triple_range(role, indices), ())
+    }
 }
 
 struct RawRandomBitIter<F, C> {
@@ -135,4 +149,5 @@ where
     .next()
     .await
     .unwrap()
+    .map(|(v, ())| v)
 }
diff --git a/src/protocol/modulus_conversion/convert_shares.rs b/src/protocol/modulus_conversion/convert_shares.rs
index 406c05fdc..87df09abf 100644
--- a/src/protocol/modulus_conversion/convert_shares.rs
+++ b/src/protocol/modulus_conversion/convert_shares.rs
@@ -96,11 +96,13 @@ impl<F: PrimeField> BitConversionTriple<Replicated<F>> {
 }
 
 pub trait ToBitConversionTriples {
+    /// The type of a collection of fields that need to be carried in the stream without conversion.
+    type Residual: Send; // TODO: associated type defaults would be nice here.
+
     /// Get the maximum number of bits that can be produced for this type.
     ///
     /// Note that this should be an associated constant, but one of the implementations would then need
     /// const generics to be more fully available in the language, so this is a method instead.  For now.
-
     fn bits(&self) -> u32;
     /// Produce a `BitConversionTriple` for the given role and bit index.
     fn triple<F: PrimeField>(&self, role: Role, i: u32) -> BitConversionTriple<Replicated<F>>;
@@ -116,9 +118,23 @@ pub trait ToBitConversionTriples {
     {
         BitDecomposed::new(indices.into_iter().map(|i| self.triple(role, i)))
     }
+
+    fn into_triples<F, I>(
+        self,
+        role: Role,
+        indices: I,
+    ) -> (
+        BitDecomposed<BitConversionTriple<Replicated<F>>>,
+        Self::Residual,
+    )
+    where
+        F: PrimeField,
+        I: IntoIterator<Item = u32>;
 }
 
 impl<B: GaloisField> ToBitConversionTriples for Replicated<B> {
+    type Residual = ();
+
     fn bits(&self) -> u32 {
         B::BITS
     }
@@ -126,9 +142,26 @@ impl<B: GaloisField> ToBitConversionTriples for Replicated<B> {
     fn triple<F: PrimeField>(&self, role: Role, i: u32) -> BitConversionTriple<Replicated<F>> {
         BitConversionTriple::new(role, self.left()[i], self.right()[i])
     }
+
+    fn into_triples<F, I>(
+        self,
+        role: Role,
+        indices: I,
+    ) -> (
+        BitDecomposed<BitConversionTriple<Replicated<F>>>,
+        Self::Residual,
+    )
+    where
+        F: PrimeField,
+        I: IntoIterator<Item = u32>,
+    {
+        (self.triple_range(role, indices), ())
+    }
 }
 
 impl ToBitConversionTriples for BitDecomposed<Replicated<Gf2>> {
+    type Residual = ();
+
     fn bits(&self) -> u32 {
         u32::try_from(self.len()).unwrap()
     }
@@ -138,13 +171,28 @@ impl ToBitConversionTriples for BitDecomposed<Replicated<Gf2>> {
         let i = usize::try_from(i).unwrap();
         BitConversionTriple::new(role, self[i].left()[BIT0], self[i].right()[BIT0])
     }
+
+    fn into_triples<F, I>(
+        self,
+        role: Role,
+        indices: I,
+    ) -> (
+        BitDecomposed<BitConversionTriple<Replicated<F>>>,
+        Self::Residual,
+    )
+    where
+        F: PrimeField,
+        I: IntoIterator<Item = u32>,
+    {
+        (self.triple_range(role, indices), ())
+    }
 }
 
 #[pin_project]
-pub struct LocalBitConverter<F, V, S>
+pub struct LocalBitConverter<F, V, S, R>
 where
     F: PrimeField,
-    V: ToBitConversionTriples,
+    V: ToBitConversionTriples<Residual = R>,
     S: Stream<Item = V> + Send,
 {
     role: Role,
@@ -154,10 +202,10 @@ where
     _f: PhantomData<F>,
 }
 
-impl<F, V, S> LocalBitConverter<F, V, S>
+impl<F, V, S, R> LocalBitConverter<F, V, S, R>
 where
     F: PrimeField,
-    V: ToBitConversionTriples,
+    V: ToBitConversionTriples<Residual = R>,
     S: Stream<Item = V> + Send,
 {
     pub fn new(role: Role, input: S, bits: Range<u32>) -> Self {
@@ -170,19 +218,19 @@ where
     }
 }
 
-impl<F, V, S> Stream for LocalBitConverter<F, V, S>
+impl<F, V, S, R> Stream for LocalBitConverter<F, V, S, R>
 where
     F: PrimeField,
-    V: ToBitConversionTriples,
+    V: ToBitConversionTriples<Residual = R>,
     S: Stream<Item = V> + Send,
 {
-    type Item = BitDecomposed<BitConversionTriple<Replicated<F>>>;
+    type Item = (BitDecomposed<BitConversionTriple<Replicated<F>>>, R);
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut TaskContext<'_>) -> Poll<Option<Self::Item>> {
         let mut this = self.project();
         match this.input.as_mut().poll_next(cx) {
             Poll::Ready(Some(input)) => {
-                Poll::Ready(Some(input.triple_range(*this.role, this.bits.clone())))
+                Poll::Ready(Some(input.into_triples(*this.role, this.bits.clone())))
             }
             Poll::Ready(None) => Poll::Ready(None),
             Poll::Pending => Poll::Pending,
@@ -194,10 +242,10 @@ where
     }
 }
 
-impl<F, V, S> ExactSizeStream for LocalBitConverter<F, V, S>
+impl<F, V, S, R> ExactSizeStream for LocalBitConverter<F, V, S, R>
 where
     F: PrimeField,
-    V: ToBitConversionTriples,
+    V: ToBitConversionTriples<Residual = R>,
     S: Stream<Item = V> + Send,
 {
 }
@@ -251,7 +299,28 @@ pub fn convert_bits<F, V, C, S, VS>(
 ) -> impl Stream<Item = Result<BitDecomposed<S>, Error>>
 where
     F: PrimeField,
-    V: ToBitConversionTriples,
+    V: ToBitConversionTriples<Residual = ()>,
+    C: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + SecureMul<C>,
+    VS: Stream<Item = V> + Unpin + Send,
+    for<'u> UpgradeContext<'u, C, F, RecordId>:
+        UpgradeToMalicious<'u, BitConversionTriple<Replicated<F>>, BitConversionTriple<C::Share>>,
+{
+    convert_some_bits(ctx, binary_shares, RecordId::FIRST, bit_range).map(|v| v.map(|(v, ())| v))
+}
+
+/// A version of `convert_bits` that allows for the retention of unconverted fields in the input.
+/// Note that unconverted fields are not upgraded, so they might need to be upgraded either before or
+/// after invoking this function.
+#[tracing::instrument(name = "modulus_conversion", skip_all, fields(bits = ?bit_range, gate = %ctx.gate().as_ref()))]
+pub fn convert_selected_bits<F, V, C, S, VS, R>(
+    ctx: C,
+    binary_shares: VS,
+    bit_range: Range<u32>,
+) -> impl Stream<Item = Result<(BitDecomposed<S>, R), Error>>
+where
+    F: PrimeField,
+    V: ToBitConversionTriples<Residual = R>,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + SecureMul<C>,
     VS: Stream<Item = V> + Unpin + Send,
@@ -261,15 +330,15 @@ where
     convert_some_bits(ctx, binary_shares, RecordId::FIRST, bit_range)
 }
 
-pub(crate) fn convert_some_bits<F, V, C, S, VS>(
+pub(crate) fn convert_some_bits<F, V, C, S, VS, R>(
     ctx: C,
     binary_shares: VS,
     first_record: RecordId,
     bit_range: Range<u32>,
-) -> impl Stream<Item = Result<BitDecomposed<S>, Error>>
+) -> impl Stream<Item = Result<(BitDecomposed<S>, R), Error>>
 where
     F: PrimeField,
-    V: ToBitConversionTriples,
+    V: ToBitConversionTriples<Residual = R>,
     C: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + SecureMul<C>,
     VS: Stream<Item = V> + Unpin + Send,
@@ -288,7 +357,7 @@ where
     let stream = unfold(
         (ctx, locally_converted, first_record),
         |(ctx, mut locally_converted, record_id)| async move {
-            let Some(triple) = locally_converted.next().await else {
+            let Some((triple, residual)) = locally_converted.next().await else {
                 return None;
             };
             let bit_contexts = (0..).map(|i| ctx.narrow(&ConvertSharesStep::ConvertBit(i)));
@@ -300,10 +369,15 @@ where
                         .await?;
                     convert_bit(ctx, record_id, &upgraded).await
                 }));
-            Some((converted, (ctx, locally_converted, record_id + 1)))
+            Some((
+                (converted, residual),
+                (ctx, locally_converted, record_id + 1),
+            ))
         },
     )
-    .map(|res| async move { res.await.map(|bits| BitDecomposed::new(bits)) });
+    .map(|(row, residual)| async move {
+        row.await.map(|bits| (BitDecomposed::new(bits), residual))
+    });
     seq_join(active, stream)
 }
 
@@ -315,16 +389,20 @@ mod tests {
 
     use crate::{
         error::Error,
-        ff::{Field, Fp31, Fp32BitPrime},
+        ff::{Field, Fp31, Fp32BitPrime, Gf2, PrimeField},
         helpers::{Direction, Role},
         protocol::{
             context::{Context, UpgradableContext, UpgradedContext, Validator},
-            modulus_conversion::{convert_bits, BitConversionTriple, LocalBitConverter},
+            modulus_conversion::{
+                convert_bits, convert_selected_bits, BitConversionTriple, LocalBitConverter,
+                ToBitConversionTriples,
+            },
             MatchKey, RecordId,
         },
         rand::{thread_rng, Rng},
-        secret_sharing::replicated::{
-            semi_honest::AdditiveShare as Replicated, ReplicatedSecretSharing,
+        secret_sharing::{
+            replicated::{semi_honest::AdditiveShare as Replicated, ReplicatedSecretSharing},
+            IntoShares,
         },
         test_fixture::{Reconstruct, Runner, TestWorld},
     };
@@ -356,6 +434,123 @@ mod tests {
         assert_eq!(Fp31::truncate_from(match_key[BITNUM]), result.reconstruct());
     }
 
+    struct TwoBits {
+        convert: Replicated<Gf2>,
+        keep: Replicated<Gf2>,
+    }
+
+    impl ToBitConversionTriples for TwoBits {
+        type Residual = Replicated<Gf2>;
+
+        fn bits(&self) -> u32 {
+            1
+        }
+
+        fn triple<F: PrimeField>(&self, role: Role, i: u32) -> BitConversionTriple<Replicated<F>> {
+            assert_eq!(i, 0, "there is only one convertible bit in TwoBits");
+            BitConversionTriple::new(
+                role,
+                self.convert.left() == Gf2::ONE,
+                self.convert.right() == Gf2::ONE,
+            )
+        }
+
+        fn into_triples<F, I>(
+            self,
+            role: Role,
+            indices: I,
+        ) -> (
+            crate::secret_sharing::BitDecomposed<BitConversionTriple<Replicated<F>>>,
+            Self::Residual,
+        )
+        where
+            F: PrimeField,
+            I: IntoIterator<Item = u32>,
+        {
+            (self.triple_range(role, indices), self.keep)
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    struct TwoBitsRaw {
+        convert: bool,
+        keep: bool,
+    }
+
+    impl rand::distributions::Distribution<TwoBitsRaw> for rand::distributions::Standard {
+        fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> TwoBitsRaw {
+            let r = rng.next_u32();
+            TwoBitsRaw {
+                convert: r & 1 == 1,
+                keep: r & 2 == 2,
+            }
+        }
+    }
+
+    impl IntoShares<TwoBits> for TwoBitsRaw {
+        fn share_with<R: Rng>(self, rng: &mut R) -> [TwoBits; 3] {
+            let r = rng.next_u32();
+            let mut offset = 0;
+            let mut next_bit = || {
+                let b = (r >> offset) & 1 == 1;
+                offset += 1;
+                Gf2::from(b)
+            };
+
+            let c0 = next_bit();
+            let c1 = next_bit();
+            let k0 = next_bit();
+            let k1 = next_bit();
+            let c2 = c0 + c1 + Gf2::from(self.convert);
+            let k2 = k0 + k1 + Gf2::from(self.keep);
+            [
+                TwoBits {
+                    convert: Replicated::new(c0, c1),
+                    keep: Replicated::new(k0, k1),
+                },
+                TwoBits {
+                    convert: Replicated::new(c1, c2),
+                    keep: Replicated::new(k1, k2),
+                },
+                TwoBits {
+                    convert: Replicated::new(c2, c0),
+                    keep: Replicated::new(k2, k0),
+                },
+            ]
+        }
+    }
+
+    #[tokio::test]
+    pub async fn retain() {
+        let mut rng = thread_rng();
+        let world = TestWorld::default();
+        let two_bits = rng.gen::<TwoBitsRaw>();
+        let result: [(Replicated<Fp31>, Replicated<Gf2>); 3] = world
+            .semi_honest(two_bits, |ctx, bits_share| async move {
+                let v = ctx.validator();
+                let result = convert_selected_bits(
+                    v.context().set_total_records(1),
+                    once(ready(bits_share)),
+                    0..1,
+                )
+                .try_collect::<Vec<_>>()
+                .await
+                .unwrap();
+                assert_eq!(result.len(), 1);
+                let (converted, kept) = result.into_iter().next().unwrap();
+                assert_eq!(converted.len(), 1);
+                (converted.into_iter().next().unwrap(), kept)
+            })
+            .await;
+        assert_eq!(
+            (
+                Fp31::truncate_from(two_bits.convert),
+                Gf2::from(two_bits.keep)
+            ),
+            result.reconstruct()
+        );
+    }
+
     #[tokio::test]
     pub async fn one_bit_malicious() {
         const BITNUM: u32 = 4;
@@ -426,14 +621,15 @@ mod tests {
             let match_key = rng.gen::<MatchKey>();
             world
                 .malicious(match_key, |ctx, mk_share| async move {
-                    let triples = LocalBitConverter::<Fp32BitPrime, Replicated<MatchKey>, _>::new(
-                        ctx.role(),
-                        once(ready(mk_share)),
-                        0..1,
-                    )
-                    .collect::<Vec<_>>()
-                    .await;
-                    let tweaked = tweak.flip_bit(ctx.role(), triples[0][0].clone());
+                    let triples =
+                        LocalBitConverter::<Fp32BitPrime, Replicated<MatchKey>, _, ()>::new(
+                            ctx.role(),
+                            once(ready(mk_share)),
+                            0..1,
+                        )
+                        .collect::<Vec<_>>()
+                        .await;
+                    let tweaked = tweak.flip_bit(ctx.role(), triples[0].0[0].clone());
 
                     let v = ctx.validator();
                     let m_triples = v.context().upgrade([tweaked]).await.unwrap();
diff --git a/src/protocol/modulus_conversion/mod.rs b/src/protocol/modulus_conversion/mod.rs
index 9e4d53716..67a5e8ef9 100644
--- a/src/protocol/modulus_conversion/mod.rs
+++ b/src/protocol/modulus_conversion/mod.rs
@@ -3,5 +3,6 @@ pub mod convert_shares;
 // TODO: wean usage off convert_some_bits.
 pub(crate) use convert_shares::convert_some_bits;
 pub use convert_shares::{
-    convert_bits, BitConversionTriple, LocalBitConverter, ToBitConversionTriples,
+    convert_bits, convert_selected_bits, BitConversionTriple, LocalBitConverter,
+    ToBitConversionTriples,
 };
diff --git a/src/protocol/sort/generate_permutation.rs b/src/protocol/sort/generate_permutation.rs
index 11b02ea3b..9a7cb969d 100644
--- a/src/protocol/sort/generate_permutation.rs
+++ b/src/protocol/sort/generate_permutation.rs
@@ -116,7 +116,7 @@ where
     S: LinearSecretSharing<F> + BasicProtocols<C::UpgradedContext<F>, F> + 'static,
     ShuffledPermutationWrapper<S, C::UpgradedContext<F>>: DowngradeMalicious<Target = Vec<u32>>,
     I: Stream,
-    I::Item: ToBitConversionTriples + Clone + Send + Sync,
+    I::Item: ToBitConversionTriples<Residual = ()> + Clone + Send + Sync,
     for<'u> UpgradeContext<'u, C::UpgradedContext<F>, F, RecordId>:
         UpgradeToMalicious<'u, BitConversionTriple<Replicated<F>>, BitConversionTriple<S>>,
 {
diff --git a/src/protocol/sort/generate_permutation_opt.rs b/src/protocol/sort/generate_permutation_opt.rs
index 6be3ce437..3d1db3dff 100644
--- a/src/protocol/sort/generate_permutation_opt.rs
+++ b/src/protocol/sort/generate_permutation_opt.rs
@@ -96,7 +96,7 @@ where
     C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
     S: LinearSecretSharing<F> + BasicProtocols<C::UpgradedContext<F>, F> + 'static,
     I: Stream,
-    I::Item: ToBitConversionTriples + Clone + Send + Sync,
+    I::Item: ToBitConversionTriples<Residual = ()> + Clone + Send + Sync,
     ShuffledPermutationWrapper<S, C::UpgradedContext<F>>: DowngradeMalicious<Target = Vec<u32>>,
     for<'u> UpgradeContext<'u, C::UpgradedContext<F>, F, RecordId>:
         UpgradeToMalicious<'u, BitConversionTriple<Replicated<F>>, BitConversionTriple<S>>,

From a1d5d8986c5615de4632a0d46d929e63e022d371 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Wed, 1 Nov 2023 16:00:20 +0800
Subject: [PATCH 078/105] WIP

---
 src/protocol/mod.rs              |   4 +-
 src/protocol/prf_sharding/mod.rs | 296 ++++++++++++++++++-------------
 2 files changed, 174 insertions(+), 126 deletions(-)

diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index cc0ae5ab8..bd434dd5b 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -21,13 +21,13 @@ pub use basics::BasicProtocols;
 
 use crate::{
     error::Error,
-    ff::{Gf20Bit, Gf3Bit, Gf40Bit, Gf8Bit},
+    ff::{Gf20Bit, Gf3Bit, Gf40Bit, Gf8Bit, Gf32Bit},
 };
 
 pub type MatchKey = Gf40Bit;
 pub type BreakdownKey = Gf8Bit;
 pub type TriggerValue = Gf3Bit;
-pub type Timestamp = Gf20Bit;
+pub type Timestamp = Gf32Bit;
 
 /// Unique identifier of the MPC query requested by report collectors
 /// TODO(615): Generating this unique id may be tricky as it may involve communication between helpers and
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index fcca9ab97..535517ca2 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -1,13 +1,16 @@
 use std::{
     iter::{repeat, zip},
     num::NonZeroU32,
+    pin::pin,
 };
 
 use futures::{stream::iter as stream_iter, TryStreamExt};
 use futures_util::{
     future::{try_join, try_join3},
-    StreamExt,
+    stream::unfold,
+    Stream, StreamExt,
 };
+
 use ipa_macros::Step;
 
 use super::boolean::saturating_sum::SaturatingSum;
@@ -293,32 +296,61 @@ where
     context_per_row_depth
 }
 
-fn chunk_rows_by_user<BK, TV, TS>(
-    input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
-) -> Vec<Vec<PrfShardedIpaInputRow<BK, TV, TS>>>
+///
+/// Takes an input stream of `PrfShardedIpaInputRecordRow` which is assumed to have all records with a given PRF adjacent
+/// and converts it into a stream of vectors of `PrfShardedIpaInputRecordRow` having the same PRF.
+///
+fn chunk_rows_by_user<IS, BK, TV, TS>(
+    input_stream: IS,
+    first_row: PrfShardedIpaInputRow<BK, TV, TS>,
+) -> impl Stream<Item = Vec<PrfShardedIpaInputRow<BK, TV, TS>>>
 where
     BK: GaloisField,
     TV: GaloisField,
     TS: GaloisField,
+    IS: Stream<Item = PrfShardedIpaInputRow<BK, TV, TS>> + Unpin,
 {
-    let mut rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV, TS>> = vec![];
-
-    let mut rows_chunked_by_user = vec![];
-    for row in input_rows {
-        if rows_for_user.is_empty() || row.prf_of_match_key == rows_for_user[0].prf_of_match_key {
-            rows_for_user.push(row);
-        } else {
-            rows_chunked_by_user.push(rows_for_user);
-            rows_for_user = vec![row];
+    unfold(Some((input_stream, first_row)), |state| async move {
+        let (mut s, last_row) = state?;
+        let last_row_prf = last_row.prf_of_match_key;
+        let mut current_chunk = vec![last_row];
+        while let Some(row) = s.next().await {
+            if row.prf_of_match_key == last_row_prf {
+                current_chunk.push(row);
+            } else {
+                return Some((current_chunk, Some((s, row))));
+            }
         }
-    }
-    if !rows_for_user.is_empty() {
-        rows_chunked_by_user.push(rows_for_user);
-    }
-
-    rows_chunked_by_user
+        Some((current_chunk, None))
+    })
 }
 
+// fn chunk_rows_by_user<BK, TV, TS>(
+//     input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
+// ) -> Vec<Vec<PrfShardedIpaInputRow<BK, TV, TS>>>
+// where
+//     BK: GaloisField,
+//     TV: GaloisField,
+//     TS: GaloisField,
+// {
+//     let mut rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV, TS>> = vec![];
+
+//     let mut rows_chunked_by_user = vec![];
+//     for row in input_rows {
+//         if rows_for_user.is_empty() || row.prf_of_match_key == rows_for_user[0].prf_of_match_key {
+//             rows_for_user.push(row);
+//         } else {
+//             rows_chunked_by_user.push(rows_for_user);
+//             rows_for_user = vec![row];
+//         }
+//     }
+//     if !rows_for_user.is_empty() {
+//         rows_chunked_by_user.push(rows_for_user);
+//     }
+
+//     rows_chunked_by_user
+// }
+
 /// Sub-protocol of the PRF-sharded IPA Protocol
 ///
 /// After the computation of the per-user PRF, addition of dummy records and shuffling,
@@ -341,6 +373,7 @@ pub async fn attribution_and_capping<C, BK, TV, TS>(
     input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
     num_saturating_sum_bits: usize,
     attribution_window_seconds: Option<NonZeroU32>,
+    histogram: &[usize],
 ) -> Result<Vec<CappedAttributionOutputs>, Error>
 where
     C: UpgradableContext,
@@ -354,43 +387,121 @@ where
     assert!(BK::BITS > 0);
     assert!(TS::BITS > 0);
 
-    let rows_chunked_by_user = chunk_rows_by_user(input_rows);
-    let histogram = compute_histogram_of_users_with_row_count(&rows_chunked_by_user);
+    // Get the validator and context to use for Gf2 multiplication operations
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
-    let mut num_users_who_encountered_row_depth = Vec::with_capacity(histogram.len());
-    let ctx_for_row_number = set_up_contexts(&binary_m_ctx, &histogram);
-    let mut futures = Vec::with_capacity(rows_chunked_by_user.len());
-    for rows_for_user in rows_chunked_by_user {
-        for i in 0..rows_for_user.len() {
-            if i >= num_users_who_encountered_row_depth.len() {
-                num_users_who_encountered_row_depth.push(0);
-            }
-            num_users_who_encountered_row_depth[i] += 1;
-        }
 
-        futures.push(evaluate_per_user_attribution_circuit(
-            &ctx_for_row_number,
-            num_users_who_encountered_row_depth
-                .iter()
-                .take(rows_for_user.len())
-                .map(|x| RecordId(x - 1))
-                .collect(),
-            rows_for_user,
-            num_saturating_sum_bits,
-            attribution_window_seconds,
-        ));
+    // Tricky hacks to work around the limitations of our current infrastructure
+    let num_outputs = input_rows.len() - histogram[0];
+    let mut record_id_for_row_depth = vec![0_u32; histogram.len()];
+    let ctx_for_row_number = set_up_contexts(&binary_m_ctx, histogram);
+
+    // Chunk the incoming stream of records into stream of vectors of records with the same PRF
+    let mut input_stream = stream_iter(input_rows);
+    let first_row = input_stream.next().await;
+    if first_row.is_none() {
+        return Ok(vec![]);
     }
-    let outputs_chunked_by_user = sh_ctx.parallel_join(futures).await?;
-    Ok(outputs_chunked_by_user
+    let first_row = first_row.unwrap();
+    let rows_chunked_by_user = chunk_rows_by_user(input_stream, first_row);
+
+    // Convert to a stream of async futures that represent the result of executing the per-user circuit
+    let stream_of_per_user_circuits = pin!(rows_chunked_by_user.then(|rows_for_user| {
+        let num_user_rows = rows_for_user.len();
+        let contexts = ctx_for_row_number[..num_user_rows - 1].to_owned();
+        let record_ids = record_id_for_row_depth[..num_user_rows].to_owned();
+
+        for count in &mut record_id_for_row_depth[..num_user_rows] {
+            *count += 1;
+        }
+        #[allow(clippy::async_yields_async)]
+        // this is ok, because seq join wants a stream of futures
+        async move {
+            evaluate_per_user_attribution_circuit(
+                contexts,
+                record_ids,
+                rows_for_user,
+                num_saturating_sum_bits,
+                attribution_window_seconds,
+            )
+        }
+    }));
+
+    // Execute all of the async futures (sequentially), and flatten the result
+    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
+        .flat_map(|x| stream_iter(x.unwrap()));
+
+    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
         .into_iter()
-        .flatten()
-        .collect::<Vec<CappedAttributionOutputs>>())
+        .map(|row| {
+            (
+                row.attributed_breakdown_key_bits,
+                row.capped_attributed_trigger_value,
+            )
+        })
+        .unzip();
+
+    // modulus convert breakdown keys
+    let converted_bks = convert_bits(
+        ctx.narrow(&Step::ModulusConvertBreakdownKeyBits)
+            .set_total_records(num_records),
+        stream_iter(bk_vec),
+        0..BK::BITS,
+    );
+    // modulus convert attributed value
+    let converted_values = convert_bits(
+        ctx.narrow(&Step::ModulusConvertConversionValueBits)
+            .set_total_records(num_records),
+        stream_iter(tv_vec),
+        0..TV::BITS,
+    );
+
+    // transform value bits to large field
+    let large_field_values = converted_values
+        .map(|val| BitDecomposed::to_additive_sharing_in_large_field_consuming(val.unwrap()));
+
+    // move each value to the correct bucket
+    let row_contributions_stream = converted_bks
+        .zip(large_field_values)
+        .zip(futures::stream::repeat(
+            ctx.narrow(&Step::MoveValueToCorrectBreakdown)
+                .set_total_records(num_records),
+        ))
+        .enumerate()
+        .map(|(i, ((bk_bits, value), ctx))| {
+            let record_id: RecordId = RecordId::from(i);
+            let bd_key = bk_bits.unwrap();
+            async move {
+                bucket::move_single_value_to_bucket::<BK, _, _, _>(
+                    ctx,
+                    record_id,
+                    bd_key,
+                    value,
+                    1 << BK::BITS,
+                    false,
+                )
+                .await
+            }
+        });
+
+    // aggregate all row level contributions
+    let row_contributions = seq_join(ctx.active_work(), row_contributions_stream);
+    row_contributions
+        .try_fold(
+            vec![S::ZERO; 1 << BK::BITS],
+            |mut running_sums, row_contribution| async move {
+                for (i, contribution) in row_contribution.iter().enumerate() {
+                    running_sums[i] += contribution;
+                }
+                Ok(running_sums)
+            },
+        )
+        .await
 }
 
 async fn evaluate_per_user_attribution_circuit<C, BK, TV, TS>(
-    ctx_for_row_number: &[C],
-    record_id_for_each_depth: Vec<RecordId>,
+    ctx_for_row_number: Vec<C>,
+    record_id_for_each_depth: Vec<u32>,
     rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
     num_saturating_sum_bits: usize,
     attribution_window_seconds: Option<NonZeroU32>,
@@ -415,7 +526,7 @@ where
     let mut output = Vec::with_capacity(rows_for_user.len() - 1);
     for (i, row) in rows_for_user.iter().skip(1).enumerate() {
         let ctx_for_this_row_depth = ctx_for_row_number[i].clone(); // no context was created for row 0
-        let record_id_for_this_row_depth = record_id_for_each_depth[i + 1]; // skip row 0
+        let record_id_for_this_row_depth = RecordId::from(record_id_for_each_depth[i + 1]); // skip row 0
 
         let capped_attribution_outputs = prev_row_inputs
             .compute_row_with_previous(
@@ -714,6 +825,7 @@ pub async fn attribution_and_capping_and_aggregation<C, BK, TV, TS, F, S, SB>(
     input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
     num_saturating_sum_bits: usize,
     attribution_window_seconds: Option<NonZeroU32>,
+    histogram: &[usize],
 ) -> Result<Vec<S>, Error>
 where
     C: UpgradableContext,
@@ -733,6 +845,7 @@ where
         input_rows,
         num_saturating_sum_bits,
         attribution_window_seconds,
+        histogram,
     )
     .await?;
 
@@ -758,80 +871,7 @@ where
     TV: GaloisField,
     F: PrimeField + ExtendableField,
 {
-    let num_records = user_level_attributions.len();
-
-    // in case no attributable conversion is found, return 0.
-    // as anyways the helpers know that no attributions resulted.
-    if num_records == 0 {
-        return Ok(vec![S::ZERO; 1 << BK::BITS]);
-    }
-
-    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
-        .into_iter()
-        .map(|row| {
-            (
-                row.attributed_breakdown_key_bits,
-                row.capped_attributed_trigger_value,
-            )
-        })
-        .unzip();
-
-    // modulus convert breakdown keys
-    let converted_bks = convert_bits(
-        ctx.narrow(&Step::ModulusConvertBreakdownKeyBits)
-            .set_total_records(num_records),
-        stream_iter(bk_vec),
-        0..BK::BITS,
-    );
-    // modulus convert attributed value
-    let converted_values = convert_bits(
-        ctx.narrow(&Step::ModulusConvertConversionValueBits)
-            .set_total_records(num_records),
-        stream_iter(tv_vec),
-        0..TV::BITS,
-    );
-
-    // transform value bits to large field
-    let large_field_values = converted_values
-        .map(|val| BitDecomposed::to_additive_sharing_in_large_field_consuming(val.unwrap()));
-
-    // move each value to the correct bucket
-    let row_contributions_stream = converted_bks
-        .zip(large_field_values)
-        .zip(futures::stream::repeat(
-            ctx.narrow(&Step::MoveValueToCorrectBreakdown)
-                .set_total_records(num_records),
-        ))
-        .enumerate()
-        .map(|(i, ((bk_bits, value), ctx))| {
-            let record_id: RecordId = RecordId::from(i);
-            let bd_key = bk_bits.unwrap();
-            async move {
-                bucket::move_single_value_to_bucket::<BK, _, _, _>(
-                    ctx,
-                    record_id,
-                    bd_key,
-                    value,
-                    1 << BK::BITS,
-                    false,
-                )
-                .await
-            }
-        });
-
-    // aggregate all row level contributions
-    let row_contributions = seq_join(ctx.active_work(), row_contributions_stream);
-    row_contributions
-        .try_fold(
-            vec![S::ZERO; 1 << BK::BITS],
-            |mut running_sums, row_contribution| async move {
-                for (i, contribution) in row_contribution.iter().enumerate() {
-                    running_sums[i] += contribution;
-                }
-                Ok(running_sums)
-            },
-        )
-        .await
+    
 }
 
 #[cfg(all(test, unit_test))]
@@ -1087,6 +1127,8 @@ pub mod tests {
             ];
             let num_saturating_bits: usize = 5;
 
+            let histogram = [3, 3, 2, 2, 1, 1, 1, 1];
+
             let result: Vec<_> = world
                 .semi_honest(records.into_iter(), |ctx, input_rows| async move {
                     attribution_and_capping::<_, Gf5Bit, Gf3Bit, Gf20Bit>(
@@ -1094,6 +1136,7 @@ pub mod tests {
                         input_rows,
                         num_saturating_bits,
                         None,
+                        &histogram,
                     )
                     .await
                     .unwrap()
@@ -1145,6 +1188,8 @@ pub mod tests {
             ];
             let num_saturating_bits: usize = 5;
 
+            let histogram = [3, 3, 2, 2, 1, 1, 1, 1];
+
             let result: Vec<_> = world
                 .semi_honest(records.into_iter(), |ctx, input_rows| async move {
                     attribution_and_capping::<_, Gf5Bit, Gf3Bit, Gf20Bit>(
@@ -1152,6 +1197,7 @@ pub mod tests {
                         input_rows,
                         num_saturating_bits,
                         NonZeroU32::new(200),
+                        &histogram,
                     )
                     .await
                     .unwrap()
@@ -1194,6 +1240,8 @@ pub mod tests {
 
             let num_saturating_bits: usize = 5;
 
+            let histogram = [3, 3, 2, 2, 1, 1, 1, 1];
+
             let result: Vec<_> = world
                 .semi_honest(records.into_iter(), |ctx, input_rows| async move {
                     attribution_and_capping_and_aggregation::<
@@ -1204,7 +1252,7 @@ pub mod tests {
                         Fp32BitPrime,
                         _,
                         Replicated<Gf2>,
-                    >(ctx, input_rows, num_saturating_bits, None)
+                    >(ctx, input_rows, num_saturating_bits, None, &histogram)
                     .await
                     .unwrap()
                 })

From 942700e332f992f2a2720edb6b8f4362a138b1ed Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Wed, 1 Nov 2023 17:29:33 +0800
Subject: [PATCH 079/105] next step of the WIP

---
 src/protocol/prf_sharding/mod.rs | 361 +++++++------------------------
 src/secret_sharing/decomposed.rs |  14 ++
 2 files changed, 88 insertions(+), 287 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 535517ca2..946887b35 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -13,15 +13,16 @@ use futures_util::{
 
 use ipa_macros::Step;
 
-use super::boolean::saturating_sum::SaturatingSum;
+use super::{boolean::saturating_sum::SaturatingSum, modulus_conversion::ToBitConversionTriples};
 use crate::{
     error::Error,
     ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
+    helpers::Role,
     protocol::{
         basics::{if_else, SecureMul, ShareKnownValue},
         boolean::{comparison::bitwise_less_than_constant, or::or},
-        context::{UpgradableContext, UpgradedContext, Validator},
-        modulus_conversion::convert_bits,
+        context::{UpgradableContext, UpgradedContext, Validator, Context},
+        modulus_conversion::{convert_bits, BitConversionTriple},
         step::BitOpStep,
         RecordId,
     },
@@ -32,7 +33,7 @@ use crate::{
         },
         BitDecomposed, Linear as LinearSecretSharing, SharedValue,
     },
-    seq_join::seq_join,
+    seq_join::{seq_join, SeqJoin},
 };
 
 pub mod bucket;
@@ -219,6 +220,43 @@ pub struct CappedAttributionOutputs {
     pub capped_attributed_trigger_value: BitDecomposed<Replicated<Gf2>>,
 }
 
+impl ToBitConversionTriples for CappedAttributionOutputs {
+    type Residual = ();
+
+    fn bits(&self) -> u32 {
+        (self.attributed_breakdown_key_bits.len() + self.capped_attributed_trigger_value.len())
+            .try_into()
+            .unwrap()
+    }
+
+    fn triple<F: PrimeField>(&self, role: Role, i: u32) -> BitConversionTriple<Replicated<F>> {
+        assert!(i < self.bits());
+        let i: usize = i.try_into().unwrap();
+        let bit = if i < self.attributed_breakdown_key_bits.len() {
+            self.attributed_breakdown_key_bits[i]
+        } else {
+            let i = i - self.attributed_breakdown_key_bits.len();
+            self.capped_attributed_trigger_value[i]
+        };
+        BitConversionTriple::new(role, bit.left() == Gf2::ONE, bit.right() == Gf2::ONE)
+    }
+
+    fn into_triples<F, I>(
+        self,
+        role: Role,
+        indices: I,
+    ) -> (
+        BitDecomposed<BitConversionTriple<Replicated<F>>>,
+        Self::Residual,
+    )
+    where
+        F: PrimeField,
+        I: IntoIterator<Item = u32>,
+    {
+        (self.triple_range(role, indices), ())
+    }
+}
+
 #[derive(Step)]
 pub enum UserNthRowStep {
     #[dynamic(64)]
@@ -246,6 +284,7 @@ impl From<usize> for BinaryTreeDepthStep {
 #[derive(Step)]
 pub(crate) enum Step {
     BinaryValidator,
+    PrimeFieldValidator,
     EverEncounteredSourceEvent,
     DidTriggerGetAttributed,
     AttributedBreakdownKey,
@@ -260,8 +299,7 @@ pub(crate) enum Step {
     ComputeDifferenceToCap,
     ComputedCappedAttributedTriggerValueNotSaturatedCase,
     ComputedCappedAttributedTriggerValueJustSaturatedCase,
-    ModulusConvertBreakdownKeyBits,
-    ModulusConvertConversionValueBits,
+    ModulusConvertBreakdownKeyBitsAndTriggerValues,
     MoveValueToCorrectBreakdown,
 }
 
@@ -368,19 +406,22 @@ where
 /// Propagates errors from multiplications
 /// # Panics
 /// Propagates errors from multiplications
-pub async fn attribution_and_capping<C, BK, TV, TS>(
+pub async fn attribution_and_capping_and_aggregation<C, BK, TV, TS, S, F>(
     sh_ctx: C,
     input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
     num_saturating_sum_bits: usize,
     attribution_window_seconds: Option<NonZeroU32>,
     histogram: &[usize],
-) -> Result<Vec<CappedAttributionOutputs>, Error>
+) -> Result<Vec<S>, Error>
 where
     C: UpgradableContext,
     C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
+    C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
+    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F>>,
     BK: GaloisField,
     TV: GaloisField,
     TS: GaloisField,
+    F: PrimeField + ExtendableField,
 {
     assert!(num_saturating_sum_bits > TV::BITS as usize);
     assert!(TV::BITS > 0);
@@ -391,6 +432,10 @@ where
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
 
+    // Get the validator and context to use for `Z_p` operations (modulus conversion)
+    let prime_field_validator = sh_ctx.narrow(&Step::PrimeFieldValidator).validator::<F>();
+    let prime_field_ctx = prime_field_validator.context();
+
     // Tricky hacks to work around the limitations of our current infrastructure
     let num_outputs = input_rows.len() - histogram[0];
     let mut record_id_for_row_depth = vec![0_u32; histogram.len()];
@@ -431,52 +476,37 @@ where
     let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
         .flat_map(|x| stream_iter(x.unwrap()));
 
-    let (bk_vec, tv_vec): (Vec<_>, Vec<_>) = user_level_attributions
-        .into_iter()
-        .map(|row| {
-            (
-                row.attributed_breakdown_key_bits,
-                row.capped_attributed_trigger_value,
-            )
-        })
-        .unzip();
-
-    // modulus convert breakdown keys
-    let converted_bks = convert_bits(
-        ctx.narrow(&Step::ModulusConvertBreakdownKeyBits)
-            .set_total_records(num_records),
-        stream_iter(bk_vec),
-        0..BK::BITS,
-    );
-    // modulus convert attributed value
-    let converted_values = convert_bits(
-        ctx.narrow(&Step::ModulusConvertConversionValueBits)
-            .set_total_records(num_records),
-        stream_iter(tv_vec),
-        0..TV::BITS,
+    // modulus convert breakdown keys and trigger values
+    let converted_bks_and_tvs = convert_bits(
+        prime_field_ctx
+            .narrow(&Step::ModulusConvertBreakdownKeyBitsAndTriggerValues)
+            .set_total_records(num_outputs),
+        flattenned_stream,
+        0..BK::BITS + TV::BITS,
     );
 
     // transform value bits to large field
-    let large_field_values = converted_values
-        .map(|val| BitDecomposed::to_additive_sharing_in_large_field_consuming(val.unwrap()));
+    // let large_field_values = converted_values
+    //     .map(|val| BitDecomposed::to_additive_sharing_in_large_field_consuming(val.unwrap()));
 
     // move each value to the correct bucket
-    let row_contributions_stream = converted_bks
-        .zip(large_field_values)
+    let row_contributions_stream = converted_bks_and_tvs
+        // .zip(large_field_values)
         .zip(futures::stream::repeat(
-            ctx.narrow(&Step::MoveValueToCorrectBreakdown)
-                .set_total_records(num_records),
+            prime_field_ctx.narrow(&Step::MoveValueToCorrectBreakdown)
+                .set_total_records(num_outputs),
         ))
         .enumerate()
-        .map(|(i, ((bk_bits, value), ctx))| {
+        .map(|(i, (bk_and_tv_bits, ctx))| {
             let record_id: RecordId = RecordId::from(i);
-            let bd_key = bk_bits.unwrap();
+            let bk_and_tv_bits = bk_and_tv_bits.unwrap();
+            let (bk_bits, tv_bits) = bk_and_tv_bits.split_at(BK::BITS);
             async move {
                 bucket::move_single_value_to_bucket::<BK, _, _, _>(
                     ctx,
                     record_id,
-                    bd_key,
-                    value,
+                    bk_bits,
+                    BitDecomposed::to_additive_sharing_in_large_field_consuming(tv_bits),
                     1 << BK::BITS,
                     false,
                 )
@@ -485,7 +515,7 @@ where
         });
 
     // aggregate all row level contributions
-    let row_contributions = seq_join(ctx.active_work(), row_contributions_stream);
+    let row_contributions = seq_join(prime_field_ctx.active_work(), row_contributions_stream);
     row_contributions
         .try_fold(
             vec![S::ZERO; 1 << BK::BITS],
@@ -813,77 +843,16 @@ where
     ))
 }
 
-/// This circuit expects to receive records from multiple users,
-/// but with all of the records from a given user adjacent to one another, and in time order.
-///
-/// This is a wrapper function to do attribution and capping per user followed by aggregating
-/// the results per breakdown key
-/// # Errors
-/// If there is an issue in multiplication, it will error
-pub async fn attribution_and_capping_and_aggregation<C, BK, TV, TS, F, S, SB>(
-    sh_ctx: C,
-    input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
-    num_saturating_sum_bits: usize,
-    attribution_window_seconds: Option<NonZeroU32>,
-    histogram: &[usize],
-) -> Result<Vec<S>, Error>
-where
-    C: UpgradableContext,
-    C::UpgradedContext<F>: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + SecureMul<C::UpgradedContext<F>>,
-    C::UpgradedContext<Gf2>: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
-    F: PrimeField + ExtendableField,
-    TV: GaloisField,
-    BK: GaloisField,
-    TS: GaloisField,
-{
-    let prime_field_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<F>();
-    let prime_field_m_ctx = prime_field_validator.context();
-
-    let user_level_attributions: Vec<CappedAttributionOutputs> = attribution_and_capping(
-        sh_ctx,
-        input_rows,
-        num_saturating_sum_bits,
-        attribution_window_seconds,
-        histogram,
-    )
-    .await?;
-
-    do_aggregation::<_, BK, TV, F, S>(prime_field_m_ctx, user_level_attributions).await
-}
-
-/// Sub-protocol of the PRF-sharded IPA Protocol
-///
-/// This function receives capped user level contributions to breakdown key buckets. It does the following
-/// 1. Convert bit-shares of breakdown keys and conversion values from binary field to prime field
-/// 2. Transform conversion value bits to additive sharing
-/// 3. Move all conversion values to corresponding breakdown key bucket
-///
-/// At the end of the function, all conversions are aggregated and placed in the appropriate breakdown key bucket
-async fn do_aggregation<C, BK, TV, F, S>(
-    ctx: C,
-    user_level_attributions: Vec<CappedAttributionOutputs>,
-) -> Result<Vec<S>, Error>
-where
-    C: UpgradedContext<F, Share = S>,
-    S: LinearSecretSharing<F> + Serializable + SecureMul<C>,
-    BK: GaloisField,
-    TV: GaloisField,
-    F: PrimeField + ExtendableField,
-{
-    
-}
-
 #[cfg(all(test, unit_test))]
 pub mod tests {
     use std::num::NonZeroU32;
 
-    use super::{attribution_and_capping, CappedAttributionOutputs, PrfShardedIpaInputRow};
+    use super::{CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
         ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf20Bit, Gf3Bit, Gf5Bit},
         protocol::{
             context::{UpgradableContext, Validator},
-            prf_sharding::{attribution_and_capping_and_aggregation, do_aggregation},
+            prf_sharding::{attribution_and_capping_and_aggregation},
         },
         rand::Rng,
         secret_sharing::{
@@ -1087,127 +1056,6 @@ pub mod tests {
         }
     }
 
-    #[test]
-    fn semi_honest_attribution_and_capping_no_attribution_window() {
-        run(|| async move {
-            let world = TestWorld::default();
-
-            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit, Gf20Bit>> = vec![
-                /* First User */
-                oprf_test_input(123, false, 17, 0),
-                oprf_test_input(123, true, 0, 7),
-                oprf_test_input(123, false, 20, 0),
-                oprf_test_input(123, true, 0, 3),
-                /* Second User */
-                oprf_test_input(234, false, 12, 0),
-                oprf_test_input(234, true, 0, 5),
-                /* Third User */
-                oprf_test_input(345, false, 20, 0),
-                oprf_test_input(345, true, 0, 7),
-                oprf_test_input(345, false, 18, 0),
-                oprf_test_input(345, false, 12, 0),
-                oprf_test_input(345, true, 0, 7),
-                oprf_test_input(345, true, 0, 7),
-                oprf_test_input(345, true, 0, 7),
-                oprf_test_input(345, true, 0, 7),
-            ];
-
-            let expected: [PreAggregationTestOutputInDecimal; 11] = [
-                decimal_bd_key_and_value(17, 7),
-                decimal_bd_key_and_value(20, 0),
-                decimal_bd_key_and_value(20, 3),
-                decimal_bd_key_and_value(12, 5),
-                decimal_bd_key_and_value(20, 7),
-                decimal_bd_key_and_value(18, 0),
-                decimal_bd_key_and_value(12, 0),
-                decimal_bd_key_and_value(12, 7),
-                decimal_bd_key_and_value(12, 7),
-                decimal_bd_key_and_value(12, 7),
-                decimal_bd_key_and_value(12, 4),
-            ];
-            let num_saturating_bits: usize = 5;
-
-            let histogram = [3, 3, 2, 2, 1, 1, 1, 1];
-
-            let result: Vec<_> = world
-                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
-                    attribution_and_capping::<_, Gf5Bit, Gf3Bit, Gf20Bit>(
-                        ctx,
-                        input_rows,
-                        num_saturating_bits,
-                        None,
-                        &histogram,
-                    )
-                    .await
-                    .unwrap()
-                })
-                .await
-                .reconstruct();
-            assert_eq!(result, &expected);
-        });
-    }
-
-    #[test]
-    fn semi_honest_with_attribution_window() {
-        run(|| async move {
-            let world = TestWorld::default();
-
-            let records: Vec<PreShardedAndSortedOPRFTestInput<Gf5Bit, Gf3Bit, Gf20Bit>> = vec![
-                /* First User */
-                oprf_test_input_with_timestamp(123, false, 17, 0, 0),
-                oprf_test_input_with_timestamp(123, true, 0, 7, 100),
-                oprf_test_input_with_timestamp(123, false, 20, 0, 200),
-                oprf_test_input_with_timestamp(123, true, 0, 3, 300),
-                /* Second User */
-                oprf_test_input_with_timestamp(234, false, 12, 0, 0),
-                oprf_test_input_with_timestamp(234, true, 0, 5, 100),
-                /* Third User */
-                oprf_test_input_with_timestamp(345, false, 20, 0, 0),
-                oprf_test_input_with_timestamp(345, true, 0, 7, 100),
-                oprf_test_input_with_timestamp(345, false, 18, 0, 200),
-                oprf_test_input_with_timestamp(345, false, 12, 0, 300),
-                oprf_test_input_with_timestamp(345, true, 0, 7, 400),
-                oprf_test_input_with_timestamp(345, true, 0, 7, 499),
-                // all the following events are ignored if the attribution window is <= 200s
-                oprf_test_input_with_timestamp(345, true, 0, 7, 600),
-                oprf_test_input_with_timestamp(345, true, 0, 7, 700),
-            ];
-
-            let expected: [PreAggregationTestOutputInDecimal; 11] = [
-                decimal_bd_key_and_value(17, 7),
-                decimal_bd_key_and_value(20, 0),
-                decimal_bd_key_and_value(20, 3),
-                decimal_bd_key_and_value(12, 5),
-                decimal_bd_key_and_value(20, 7),
-                decimal_bd_key_and_value(18, 0),
-                decimal_bd_key_and_value(12, 0),
-                decimal_bd_key_and_value(12, 7),
-                decimal_bd_key_and_value(12, 7),
-                decimal_bd_key_and_value(12, 0),
-                decimal_bd_key_and_value(12, 0),
-            ];
-            let num_saturating_bits: usize = 5;
-
-            let histogram = [3, 3, 2, 2, 1, 1, 1, 1];
-
-            let result: Vec<_> = world
-                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
-                    attribution_and_capping::<_, Gf5Bit, Gf3Bit, Gf20Bit>(
-                        ctx,
-                        input_rows,
-                        num_saturating_bits,
-                        NonZeroU32::new(200),
-                        &histogram,
-                    )
-                    .await
-                    .unwrap()
-                })
-                .await
-                .reconstruct();
-            assert_eq!(result, &expected);
-        });
-    }
-
     #[test]
     fn semi_honest_aggregation_capping_attribution() {
         run(|| async move {
@@ -1261,65 +1109,4 @@ pub mod tests {
             assert_eq!(result, &expected);
         });
     }
-
-    #[test]
-    fn semi_honest_aggregation() {
-        run(|| async move {
-            let world = TestWorld::default();
-
-            let records: Vec<PreAggregationTestInputInBits> = vec![
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(17, 7),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(20, 0),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(20, 3),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 5),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(20, 7),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(18, 0),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 0),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 7),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 7),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 7),
-                bitwise_bd_key_and_value::<Gf5Bit, Gf3Bit>(12, 4),
-            ];
-
-            let mut expected = [0_u128; 32];
-            expected[12] = 30;
-            expected[17] = 7;
-            expected[20] = 10;
-
-            let result: Vec<_> = world
-                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
-                    let validator = ctx.validator();
-                    let ctx = validator.context();
-                    do_aggregation::<_, Gf5Bit, Gf3Bit, Fp32BitPrime, _>(ctx, input_rows)
-                        .await
-                        .unwrap()
-                })
-                .await
-                .reconstruct();
-            assert_eq!(result, &expected);
-        });
-    }
-
-    #[test]
-    fn semi_honest_aggregation_empty_input() {
-        run(|| async move {
-            let world = TestWorld::default();
-
-            let records: Vec<PreAggregationTestInputInBits> = vec![];
-
-            let expected = [0_u128; 32];
-
-            let result: Vec<_> = world
-                .semi_honest(records.into_iter(), |ctx, input_rows| async move {
-                    let validator = ctx.validator();
-                    let ctx = validator.context();
-                    do_aggregation::<_, Gf5Bit, Gf3Bit, Fp32BitPrime, _>(ctx, input_rows)
-                        .await
-                        .unwrap()
-                })
-                .await
-                .reconstruct();
-            assert_eq!(result, &expected);
-        });
-    }
 }
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 1fc87d2c6..402571d1e 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -127,6 +127,20 @@ impl<S> BitDecomposed<S> {
 
         Ok(BitDecomposed::new(output))
     }
+
+    pub fn split_at(mut self, idx: u32) -> (BitDecomposed<S>, BitDecomposed<S>) {
+        let idx: usize = idx.try_into().unwrap();
+        let left = Vec::with_capacity(idx);
+        let right = Vec::with_capacity(self.len() - idx);
+        for (i, bit) in self.bits.into_iter().enumerate() {
+            if i < idx {
+                left.push(bit);
+            } else {
+                right.push(bit);
+            }
+        }
+        (left, right)
+    }
 }
 
 impl<S> TryFrom<Vec<S>> for BitDecomposed<S> {

From 81077448fdbf174727d0314b1897819d46226a99 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Wed, 1 Nov 2023 17:43:50 +0800
Subject: [PATCH 080/105] a step closer

---
 src/protocol/prf_sharding/mod.rs | 31 -------------------------------
 src/query/runner/oprf_ipa.rs     | 13 +++++++++++++
 2 files changed, 13 insertions(+), 31 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 946887b35..07404509e 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -363,32 +363,6 @@ where
     })
 }
 
-// fn chunk_rows_by_user<BK, TV, TS>(
-//     input_rows: Vec<PrfShardedIpaInputRow<BK, TV, TS>>,
-// ) -> Vec<Vec<PrfShardedIpaInputRow<BK, TV, TS>>>
-// where
-//     BK: GaloisField,
-//     TV: GaloisField,
-//     TS: GaloisField,
-// {
-//     let mut rows_for_user: Vec<PrfShardedIpaInputRow<BK, TV, TS>> = vec![];
-
-//     let mut rows_chunked_by_user = vec![];
-//     for row in input_rows {
-//         if rows_for_user.is_empty() || row.prf_of_match_key == rows_for_user[0].prf_of_match_key {
-//             rows_for_user.push(row);
-//         } else {
-//             rows_chunked_by_user.push(rows_for_user);
-//             rows_for_user = vec![row];
-//         }
-//     }
-//     if !rows_for_user.is_empty() {
-//         rows_chunked_by_user.push(rows_for_user);
-//     }
-
-//     rows_chunked_by_user
-// }
-
 /// Sub-protocol of the PRF-sharded IPA Protocol
 ///
 /// After the computation of the per-user PRF, addition of dummy records and shuffling,
@@ -485,13 +459,8 @@ where
         0..BK::BITS + TV::BITS,
     );
 
-    // transform value bits to large field
-    // let large_field_values = converted_values
-    //     .map(|val| BitDecomposed::to_additive_sharing_in_large_field_consuming(val.unwrap()));
-
     // move each value to the correct bucket
     let row_contributions_stream = converted_bks_and_tvs
-        // .zip(large_field_values)
         .zip(futures::stream::repeat(
             prime_field_ctx.narrow(&Step::MoveValueToCorrectBreakdown)
                 .set_total_records(num_outputs),
diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
index e77a0300e..def96d26e 100644
--- a/src/query/runner/oprf_ipa.rs
+++ b/src/query/runner/oprf_ipa.rs
@@ -71,6 +71,18 @@ where
             panic!("Encrypted match key handling is not handled for OPRF flow as yet");
         };
 
+        let mut histogram = vec![];
+        let mut last_prf = input[0].mk_oprf + 1;
+        let mut cur_count = 0;
+        for row in input {
+            if row.mk_oprf != last_prf {
+                cur_count = 0;
+            } else {
+                cur_count += 1;
+            }
+            histogram[cur_count] += 1;
+        }
+
         // TODO: Compute OPRFs and shuffle and add dummies and stuff (Daniel's code will be called here)
         let sharded_input = input
             .into_iter()
@@ -110,6 +122,7 @@ where
             sharded_input,
             user_cap.ilog2().try_into().unwrap(),
             config.attribution_window_seconds,
+            &histogram,
         )
         .await
     }

From da2ee44e3397ed6258f2ce1f15bcef8bef9f56bd Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 31 Oct 2023 13:17:12 -0700
Subject: [PATCH 081/105] Configure logging from env as well

Currently, it is not possible to have module-level granularity configuration for logging. Setting up `-vvv` makes IPA to log all trace events, including those coming from third-party.

This change enables this functionality by optionally reading logging configuration from `RUST_LOG`
---
 src/cli/verbosity.rs | 31 ++++++++++++++++++-------------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/src/cli/verbosity.rs b/src/cli/verbosity.rs
index 74346f558..53a2bee39 100644
--- a/src/cli/verbosity.rs
+++ b/src/cli/verbosity.rs
@@ -4,7 +4,7 @@ use clap::Parser;
 use metrics_tracing_context::MetricsLayer;
 use tracing::{info, metadata::LevelFilter, Level};
 use tracing_subscriber::{
-    fmt, fmt::format::FmtSpan, layer::SubscriberExt, util::SubscriberInitExt,
+    fmt, fmt::format::FmtSpan, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter,
 };
 
 use crate::{
@@ -31,14 +31,14 @@ pub struct LoggingHandle {
 impl Verbosity {
     #[must_use]
     pub fn setup_logging(&self) -> LoggingHandle {
-        let filter_layer = self.level_filter();
+        let filter_layer = self.log_filter();
         let fmt_layer = fmt::layer()
             .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
             .with_ansi(std::io::stderr().is_terminal())
             .with_writer(stderr);
 
         tracing_subscriber::registry()
-            .with(self.level_filter())
+            .with(self.log_filter())
             .with(fmt_layer)
             .with(MetricsLayer::new())
             .init();
@@ -53,15 +53,20 @@ impl Verbosity {
         handle
     }
 
-    fn level_filter(&self) -> LevelFilter {
-        if self.quiet {
-            LevelFilter::OFF
-        } else {
-            LevelFilter::from_level(match self.verbose {
-                0 => Level::INFO,
-                1 => Level::DEBUG,
-                _ => Level::TRACE,
-            })
-        }
+    fn log_filter(&self) -> EnvFilter {
+        EnvFilter::builder()
+            .with_default_directive(
+                if self.quiet {
+                    LevelFilter::OFF
+                } else {
+                    LevelFilter::from_level(match self.verbose {
+                        0 => Level::INFO,
+                        1 => Level::DEBUG,
+                        _ => Level::TRACE,
+                    })
+                }
+                .into(),
+            )
+            .from_env_lossy()
     }
 }

From b4d10d665c0c58b81d340ea659a769ecc27cf62a Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 31 Oct 2023 13:44:23 -0700
Subject: [PATCH 082/105] Add send and receive trace spans
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

```
2023-10-31T20:35:01.600364Z TRACE oprf_ipa_query{sz=10000}:send{i=914 total=1658 to=H2 gate="protocol/binary_validator/row1/attributed_breakdown_key/bit7"}: ipa::helpers::gateway::send: new
2023-10-31T20:35:01.600382Z TRACE oprf_ipa_query{sz=10000}:send{i=914 total=1658 to=H2 gate="protocol/binary_validator/row1/attributed_breakdown_key/bit7"}: ipa::helpers::gateway::send: close time.busy=2.42µs time.idle=15.7µs
```

it is a bit verbose, but logging enter/exit allows to see if send was completed (because it may be blocked if it is out of bounds) and the timing.
---
 src/helpers/gateway/receive.rs |  1 +
 src/helpers/gateway/send.rs    |  1 +
 src/helpers/mod.rs             | 12 +++++++++++-
 src/protocol/mod.rs            |  6 ++++++
 4 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/helpers/gateway/receive.rs b/src/helpers/gateway/receive.rs
index 282ff68e2..b039c8653 100644
--- a/src/helpers/gateway/receive.rs
+++ b/src/helpers/gateway/receive.rs
@@ -43,6 +43,7 @@ impl<T: Transport, M: Message> ReceivingEnd<T, M> {
     /// ## Panics
     /// This will panic if message size does not fit into 8 bytes and it somehow got serialized
     /// and sent to this helper.
+    #[tracing::instrument(level = "trace", "receive", skip_all, fields(i = %record_id, from = ?self.channel_id.role, gate = ?self.channel_id.gate.as_ref()))]
     pub async fn receive(&self, record_id: RecordId) -> Result<M, Error> {
         self.unordered_rx
             .recv::<M, _>(record_id)
diff --git a/src/helpers/gateway/send.rs b/src/helpers/gateway/send.rs
index 4eb876af0..0d32de973 100644
--- a/src/helpers/gateway/send.rs
+++ b/src/helpers/gateway/send.rs
@@ -98,6 +98,7 @@ impl<M: Message> SendingEnd<M> {
     /// call.
     ///
     /// [`set_total_records`]: crate::protocol::context::Context::set_total_records
+    #[tracing::instrument(level = "trace", "send", skip_all, fields(i = %record_id, total = %self.inner.total_records, to = ?self.channel_id.role, gate = ?self.channel_id.gate.as_ref()))]
     pub async fn send(&self, record_id: RecordId, msg: M) -> Result<(), Error> {
         let r = self.inner.send(record_id, msg).await;
         metrics::increment_counter!(RECORDS_SENT,
diff --git a/src/helpers/mod.rs b/src/helpers/mod.rs
index 373070736..359bf305f 100644
--- a/src/helpers/mod.rs
+++ b/src/helpers/mod.rs
@@ -1,5 +1,5 @@
 use std::{
-    fmt::{Debug, Formatter},
+    fmt::{Debug, Display, Formatter},
     num::NonZeroUsize,
 };
 
@@ -441,6 +441,16 @@ pub enum TotalRecords {
     Indeterminate,
 }
 
+impl Display for TotalRecords {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TotalRecords::Unspecified => write!(f, "unspecified"),
+            TotalRecords::Specified(v) => write!(f, "{v}"),
+            TotalRecords::Indeterminate => write!(f, "∞"),
+        }
+    }
+}
+
 impl TotalRecords {
     #[must_use]
     pub fn is_specified(&self) -> bool {
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index cc0ae5ab8..8c5e72c7d 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -86,6 +86,12 @@ impl TryFrom<&str> for QueryId {
 #[cfg_attr(feature = "enable-serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct RecordId(u32);
 
+impl Display for RecordId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 impl From<u32> for RecordId {
     fn from(v: u32) -> Self {
         RecordId(v)

From d2a3cd051446eb04dec3f806b91e2f0a125fd417 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 14:50:56 +0800
Subject: [PATCH 083/105] Now the tests pass

---
 src/protocol/mod.rs              |  2 +-
 src/protocol/prf_sharding/mod.rs | 64 ++++----------------------------
 src/query/runner/oprf_ipa.rs     | 14 +++++--
 src/secret_sharing/decomposed.rs |  8 ++--
 src/test_fixture/ipa.rs          | 18 ++++++++-
 5 files changed, 39 insertions(+), 67 deletions(-)

diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index bd434dd5b..387c059c1 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -21,7 +21,7 @@ pub use basics::BasicProtocols;
 
 use crate::{
     error::Error,
-    ff::{Gf20Bit, Gf3Bit, Gf40Bit, Gf8Bit, Gf32Bit},
+    ff::{Gf32Bit, Gf3Bit, Gf40Bit, Gf8Bit},
 };
 
 pub type MatchKey = Gf40Bit;
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 07404509e..d3002e0cf 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -21,7 +21,7 @@ use crate::{
     protocol::{
         basics::{if_else, SecureMul, ShareKnownValue},
         boolean::{comparison::bitwise_less_than_constant, or::or},
-        context::{UpgradableContext, UpgradedContext, Validator, Context},
+        context::{Context, UpgradableContext, UpgradedContext, Validator},
         modulus_conversion::{convert_bits, BitConversionTriple},
         step::BitOpStep,
         RecordId,
@@ -233,10 +233,10 @@ impl ToBitConversionTriples for CappedAttributionOutputs {
         assert!(i < self.bits());
         let i: usize = i.try_into().unwrap();
         let bit = if i < self.attributed_breakdown_key_bits.len() {
-            self.attributed_breakdown_key_bits[i]
+            &self.attributed_breakdown_key_bits[i]
         } else {
             let i = i - self.attributed_breakdown_key_bits.len();
-            self.capped_attributed_trigger_value[i]
+            &self.capped_attributed_trigger_value[i]
         };
         BitConversionTriple::new(role, bit.left() == Gf2::ONE, bit.right() == Gf2::ONE)
     }
@@ -303,19 +303,6 @@ pub(crate) enum Step {
     MoveValueToCorrectBreakdown,
 }
 
-fn compute_histogram_of_users_with_row_count<S>(rows_chunked_by_user: &[Vec<S>]) -> Vec<usize> {
-    let mut output = vec![];
-    for user_rows in rows_chunked_by_user {
-        for j in 0..user_rows.len() {
-            if j >= output.len() {
-                output.push(0);
-            }
-            output[j] += 1;
-        }
-    }
-    output
-}
-
 fn set_up_contexts<C>(root_ctx: &C, histogram: &[usize]) -> Vec<C>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
@@ -462,7 +449,8 @@ where
     // move each value to the correct bucket
     let row_contributions_stream = converted_bks_and_tvs
         .zip(futures::stream::repeat(
-            prime_field_ctx.narrow(&Step::MoveValueToCorrectBreakdown)
+            prime_field_ctx
+                .narrow(&Step::MoveValueToCorrectBreakdown)
                 .set_total_records(num_outputs),
         ))
         .enumerate()
@@ -814,22 +802,17 @@ where
 
 #[cfg(all(test, unit_test))]
 pub mod tests {
-    use std::num::NonZeroU32;
-
     use super::{CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
         ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf20Bit, Gf3Bit, Gf5Bit},
-        protocol::{
-            context::{UpgradableContext, Validator},
-            prf_sharding::{attribution_and_capping_and_aggregation},
-        },
+        protocol::prf_sharding::attribution_and_capping_and_aggregation,
         rand::Rng,
         secret_sharing::{
             replicated::semi_honest::AdditiveShare as Replicated, BitDecomposed, IntoShares,
             SharedValue,
         },
         test_executor::run,
-        test_fixture::{get_bits, Reconstruct, Runner, TestWorld},
+        test_fixture::{Reconstruct, Runner, TestWorld},
     };
 
     struct PreShardedAndSortedOPRFTestInput<BK: GaloisField, TV: GaloisField, TS: GaloisField> {
@@ -873,36 +856,6 @@ pub mod tests {
         }
     }
 
-    fn bitwise_bd_key_and_value<BK, TV>(
-        attributed_breakdown_key: u128,
-        capped_attributed_trigger_value: u128,
-    ) -> PreAggregationTestInputInBits
-    where
-        BK: GaloisField,
-        TV: GaloisField,
-    {
-        PreAggregationTestInputInBits {
-            attributed_breakdown_key: get_bits::<Gf2>(
-                attributed_breakdown_key.try_into().unwrap(),
-                BK::BITS,
-            ),
-            capped_attributed_trigger_value: get_bits::<Gf2>(
-                capped_attributed_trigger_value.try_into().unwrap(),
-                TV::BITS,
-            ),
-        }
-    }
-
-    fn decimal_bd_key_and_value(
-        attributed_breakdown_key: u128,
-        capped_attributed_trigger_value: u128,
-    ) -> PreAggregationTestOutputInDecimal {
-        PreAggregationTestOutputInDecimal {
-            attributed_breakdown_key,
-            capped_attributed_trigger_value,
-        }
-    }
-
     #[derive(Debug, PartialEq)]
     struct PreAggregationTestOutputInDecimal {
         attributed_breakdown_key: u128,
@@ -1066,9 +1019,8 @@ pub mod tests {
                         Gf5Bit,
                         Gf3Bit,
                         Gf20Bit,
+                        Replicated<Fp32BitPrime>,
                         Fp32BitPrime,
-                        _,
-                        Replicated<Gf2>,
                     >(ctx, input_rows, num_saturating_bits, None, &histogram)
                     .await
                     .unwrap()
diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
index def96d26e..6b1135f32 100644
--- a/src/query/runner/oprf_ipa.rs
+++ b/src/query/runner/oprf_ipa.rs
@@ -74,14 +74,21 @@ where
         let mut histogram = vec![];
         let mut last_prf = input[0].mk_oprf + 1;
         let mut cur_count = 0;
-        for row in input {
+        for row in &input {
             if row.mk_oprf != last_prf {
                 cur_count = 0;
+                last_prf = row.mk_oprf;
             } else {
                 cur_count += 1;
             }
+            if histogram.len() <= cur_count {
+                histogram.push(0);
+            }
             histogram[cur_count] += 1;
         }
+        let ref_to_histogram = &histogram;
+
+        println!("histogram: {:?}", &histogram);
 
         // TODO: Compute OPRFs and shuffle and add dummies and stuff (Daniel's code will be called here)
         let sharded_input = input
@@ -114,15 +121,14 @@ where
             BreakdownKey,
             TriggerValue,
             Timestamp,
+            Replicated<F>,
             F,
-            _,
-            Replicated<Gf2>,
         >(
             ctx,
             sharded_input,
             user_cap.ilog2().try_into().unwrap(),
             config.attribution_window_seconds,
-            &histogram,
+            ref_to_histogram,
         )
         .await
     }
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 402571d1e..94d190f9a 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -128,10 +128,10 @@ impl<S> BitDecomposed<S> {
         Ok(BitDecomposed::new(output))
     }
 
-    pub fn split_at(mut self, idx: u32) -> (BitDecomposed<S>, BitDecomposed<S>) {
+    pub fn split_at(self, idx: u32) -> (BitDecomposed<S>, BitDecomposed<S>) {
         let idx: usize = idx.try_into().unwrap();
-        let left = Vec::with_capacity(idx);
-        let right = Vec::with_capacity(self.len() - idx);
+        let mut left = Vec::with_capacity(idx);
+        let mut right = Vec::with_capacity(self.len() - idx);
         for (i, bit) in self.bits.into_iter().enumerate() {
             if i < idx {
                 left.push(bit);
@@ -139,7 +139,7 @@ impl<S> BitDecomposed<S> {
                 right.push(bit);
             }
         }
-        (left, right)
+        (BitDecomposed::new(left), BitDecomposed::new(right))
     }
 }
 
diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index e6f899b79..41e6fa7dc 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -259,6 +259,20 @@ pub async fn test_oprf_ipa<F>(
     //TODO(richaj) This manual sorting will be removed once we have the PRF sharding in place
     records.sort_by(|a, b| b.user_id.cmp(&a.user_id));
 
+    let mut histogram = Vec::new();
+    let mut last_prf = records[0].user_id + 1;
+    let mut cur_count = 0;
+    for row in &records {
+        if row.user_id != last_prf {
+            cur_count = 0;
+            last_prf = row.user_id;
+        } else {
+            cur_count += 1;
+        }
+        histogram[cur_count] += 1;
+    }
+    let ref_to_histogram = &histogram;
+
     let result: Vec<F> = world
         .semi_honest(
             records.into_iter(),
@@ -286,14 +300,14 @@ pub async fn test_oprf_ipa<F>(
                     BreakdownKey,
                     TriggerValue,
                     Timestamp,
+                    Replicated<F>,
                     F,
-                    _,
-                    Replicated<Gf2>,
                 >(
                     ctx,
                     sharded_input,
                     user_cap.ilog2().try_into().unwrap(),
                     config.attribution_window_seconds,
+                    ref_to_histogram,
                 )
                 .await
                 .unwrap()

From 7f01e0247b343248aa8491a4e3f5eff4f51013d1 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 14:52:53 +0800
Subject: [PATCH 084/105] formatting

---
 src/protocol/prf_sharding/mod.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index d3002e0cf..5dcaa98bd 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -10,7 +10,6 @@ use futures_util::{
     stream::unfold,
     Stream, StreamExt,
 };
-
 use ipa_macros::Step;
 
 use super::{boolean::saturating_sum::SaturatingSum, modulus_conversion::ToBitConversionTriples};

From 77c8a810a2a1639a7587ff87ea374cf0f045a432 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 15:39:01 +0800
Subject: [PATCH 085/105] Clippy

---
 src/query/runner/oprf_ipa.rs     | 6 +++---
 src/secret_sharing/decomposed.rs | 4 ++++
 src/test_fixture/ipa.rs          | 8 ++++----
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
index 6b1135f32..270f05fdd 100644
--- a/src/query/runner/oprf_ipa.rs
+++ b/src/query/runner/oprf_ipa.rs
@@ -75,11 +75,11 @@ where
         let mut last_prf = input[0].mk_oprf + 1;
         let mut cur_count = 0;
         for row in &input {
-            if row.mk_oprf != last_prf {
+            if row.mk_oprf == last_prf {
+                cur_count += 1;
+            } else {
                 cur_count = 0;
                 last_prf = row.mk_oprf;
-            } else {
-                cur_count += 1;
             }
             if histogram.len() <= cur_count {
                 histogram.push(0);
diff --git a/src/secret_sharing/decomposed.rs b/src/secret_sharing/decomposed.rs
index 94d190f9a..c05af674e 100644
--- a/src/secret_sharing/decomposed.rs
+++ b/src/secret_sharing/decomposed.rs
@@ -128,6 +128,10 @@ impl<S> BitDecomposed<S> {
         Ok(BitDecomposed::new(output))
     }
 
+    #[must_use]
+    ///
+    /// # Panics
+    /// If you provide an index that can't be casted to a usize
     pub fn split_at(self, idx: u32) -> (BitDecomposed<S>, BitDecomposed<S>) {
         let idx: usize = idx.try_into().unwrap();
         let mut left = Vec::with_capacity(idx);
diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index 41e6fa7dc..d8e4bc6f1 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -260,14 +260,14 @@ pub async fn test_oprf_ipa<F>(
     records.sort_by(|a, b| b.user_id.cmp(&a.user_id));
 
     let mut histogram = Vec::new();
-    let mut last_prf = records[0].user_id + 1;
+    let mut last_prf = records[0].user_id + 1; // to ensure it differs from the first row
     let mut cur_count = 0;
     for row in &records {
-        if row.user_id != last_prf {
+        if row.user_id == last_prf {
+            cur_count += 1;
+        } else {
             cur_count = 0;
             last_prf = row.user_id;
-        } else {
-            cur_count += 1;
         }
         histogram[cur_count] += 1;
     }

From 668489e829ee626d246f20b0d35007f635182f29 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 16:11:01 +0800
Subject: [PATCH 086/105] small refactor to use a common histogram generation
 function

---
 src/protocol/prf_sharding/mod.rs | 26 ++++++++++++++++++++++++++
 src/query/runner/oprf_ipa.rs     | 21 +++++----------------
 src/report.rs                    |  7 +++++++
 src/test_fixture/ipa.rs          | 25 ++++++++++++-------------
 4 files changed, 50 insertions(+), 29 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 5dcaa98bd..62b4cf08d 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -302,6 +302,32 @@ pub(crate) enum Step {
     MoveValueToCorrectBreakdown,
 }
 
+pub trait GroupingKey {
+    fn get_grouping_key(&self) -> u64;
+}
+
+pub fn compute_histogram_of_users_with_row_count<S>(input: &[S]) -> Vec<usize>
+where
+    S: GroupingKey,
+{
+    let mut histogram = vec![];
+    let mut last_prf = input[0].get_grouping_key() + 1;
+    let mut cur_count = 0;
+    for row in input {
+        if row.get_grouping_key() == last_prf {
+            cur_count += 1;
+        } else {
+            cur_count = 0;
+            last_prf = row.get_grouping_key();
+        }
+        if histogram.len() <= cur_count {
+            histogram.push(0);
+        }
+        histogram[cur_count] += 1;
+    }
+    histogram
+}
+
 fn set_up_contexts<C>(root_ctx: &C, histogram: &[usize]) -> Vec<C>
 where
     C: UpgradedContext<Gf2, Share = Replicated<Gf2>>,
diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
index 270f05fdd..0ad3b351b 100644
--- a/src/query/runner/oprf_ipa.rs
+++ b/src/query/runner/oprf_ipa.rs
@@ -12,7 +12,10 @@ use crate::{
     protocol::{
         basics::ShareKnownValue,
         context::{UpgradableContext, UpgradedContext},
-        prf_sharding::{attribution_and_capping_and_aggregation, PrfShardedIpaInputRow},
+        prf_sharding::{
+            attribution_and_capping_and_aggregation, compute_histogram_of_users_with_row_count,
+            PrfShardedIpaInputRow,
+        },
         BreakdownKey, Timestamp, TriggerValue,
     },
     report::{EventType, OprfReport},
@@ -71,21 +74,7 @@ where
             panic!("Encrypted match key handling is not handled for OPRF flow as yet");
         };
 
-        let mut histogram = vec![];
-        let mut last_prf = input[0].mk_oprf + 1;
-        let mut cur_count = 0;
-        for row in &input {
-            if row.mk_oprf == last_prf {
-                cur_count += 1;
-            } else {
-                cur_count = 0;
-                last_prf = row.mk_oprf;
-            }
-            if histogram.len() <= cur_count {
-                histogram.push(0);
-            }
-            histogram[cur_count] += 1;
-        }
+        let histogram = compute_histogram_of_users_with_row_count(&input);
         let ref_to_histogram = &histogram;
 
         println!("histogram: {:?}", &histogram);
diff --git a/src/report.rs b/src/report.rs
index 5c8ada0ae..f4a2bd4d6 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -17,6 +17,7 @@ use crate::{
         open_in_place, seal_in_place, CryptError, FieldShareCrypt, Info, KeyPair, KeyRegistry,
         PublicKeyRegistry,
     },
+    protocol::prf_sharding::GroupingKey,
     secret_sharing::replicated::semi_honest::AdditiveShare as Replicated,
 };
 
@@ -424,6 +425,12 @@ where
     pub trigger_value: Replicated<TV>,
 }
 
+impl<TS: GaloisField, BK: GaloisField, TV: GaloisField> GroupingKey for OprfReport<TS, BK, TV> {
+    fn get_grouping_key(&self) -> u64 {
+        self.mk_oprf
+    }
+}
+
 impl Serializable for u64 {
     type Size = U8;
 
diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index d8e4bc6f1..0e2b0ecb1 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -1,5 +1,6 @@
 use std::{collections::HashMap, num::NonZeroU32, ops::Deref};
 
+use crate::protocol::prf_sharding::GroupingKey;
 #[cfg(feature = "in-memory-infra")]
 use crate::{
     ff::{PrimeField, Serializable},
@@ -38,6 +39,12 @@ pub struct TestRawDataRecord {
     pub trigger_value: u32,
 }
 
+impl GroupingKey for TestRawDataRecord {
+    fn get_grouping_key(&self) -> u64 {
+        self.user_id
+    }
+}
+
 /// Executes IPA protocol in the clear, that is without any MPC helpers involved in the computation.
 /// Useful to validate that MPC output makes sense by comparing the breakdowns produced by MPC IPA
 /// with this function's results. Note that MPC version of IPA may apply DP noise to the aggregates,
@@ -243,7 +250,10 @@ pub async fn test_oprf_ipa<F>(
         ff::{Field, Gf2},
         protocol::{
             basics::ShareKnownValue,
-            prf_sharding::{attribution_and_capping_and_aggregation, PrfShardedIpaInputRow},
+            prf_sharding::{
+                attribution_and_capping_and_aggregation, compute_histogram_of_users_with_row_count,
+                PrfShardedIpaInputRow,
+            },
         },
         report::EventType,
         secret_sharing::SharedValue,
@@ -259,18 +269,7 @@ pub async fn test_oprf_ipa<F>(
     //TODO(richaj) This manual sorting will be removed once we have the PRF sharding in place
     records.sort_by(|a, b| b.user_id.cmp(&a.user_id));
 
-    let mut histogram = Vec::new();
-    let mut last_prf = records[0].user_id + 1; // to ensure it differs from the first row
-    let mut cur_count = 0;
-    for row in &records {
-        if row.user_id == last_prf {
-            cur_count += 1;
-        } else {
-            cur_count = 0;
-            last_prf = row.user_id;
-        }
-        histogram[cur_count] += 1;
-    }
+    let histogram = compute_histogram_of_users_with_row_count(&records);
     let ref_to_histogram = &histogram;
 
     let result: Vec<F> = world

From e50cbea8277aa416a65d309e4b0b8f1eab0000bc Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 16:28:43 +0800
Subject: [PATCH 087/105] Remove println and revert Timestamp change

---
 src/protocol/mod.rs          | 4 ++--
 src/query/runner/oprf_ipa.rs | 2 --
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index 387c059c1..cc0ae5ab8 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -21,13 +21,13 @@ pub use basics::BasicProtocols;
 
 use crate::{
     error::Error,
-    ff::{Gf32Bit, Gf3Bit, Gf40Bit, Gf8Bit},
+    ff::{Gf20Bit, Gf3Bit, Gf40Bit, Gf8Bit},
 };
 
 pub type MatchKey = Gf40Bit;
 pub type BreakdownKey = Gf8Bit;
 pub type TriggerValue = Gf3Bit;
-pub type Timestamp = Gf32Bit;
+pub type Timestamp = Gf20Bit;
 
 /// Unique identifier of the MPC query requested by report collectors
 /// TODO(615): Generating this unique id may be tricky as it may involve communication between helpers and
diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
index 0ad3b351b..c4e0f25f2 100644
--- a/src/query/runner/oprf_ipa.rs
+++ b/src/query/runner/oprf_ipa.rs
@@ -77,8 +77,6 @@ where
         let histogram = compute_histogram_of_users_with_row_count(&input);
         let ref_to_histogram = &histogram;
 
-        println!("histogram: {:?}", &histogram);
-
         // TODO: Compute OPRFs and shuffle and add dummies and stuff (Daniel's code will be called here)
         let sharded_input = input
             .into_iter()

From e03421e3359bc05135e229d7196f7365f342df6d Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 16:44:19 +0800
Subject: [PATCH 088/105] regen steps

---
 src/protocol/step/steps.txt | 711 ++++++++++++++++++------------------
 1 file changed, 355 insertions(+), 356 deletions(-)

diff --git a/src/protocol/step/steps.txt b/src/protocol/step/steps.txt
index c5bafcded..2ba127994 100644
--- a/src/protocol/step/steps.txt
+++ b/src/protocol/step/steps.txt
@@ -8813,362 +8813,6 @@ ipa::protocol::ipa::Step::gen_sort_permutation_from_match_keys/ipa::protocol::so
 ipa::protocol::ipa::Step::gen_sort_permutation_from_match_keys/ipa::protocol::sort::SortStep::sort_keys/ipa::protocol::step::IpaProtocolStep::sort9/ipa::protocol::sort::SortStep::shuffle_reveal_permutation/ipa::protocol::sort::ShuffleRevealPermutationStep::shuffle/ipa::protocol::sort::ShuffleStep::shuffle2
 ipa::protocol::ipa::Step::gen_sort_permutation_from_match_keys/ipa::protocol::sort::SortStep::sort_keys/ipa::protocol::step::IpaProtocolStep::sort9/ipa::protocol::sort::SortStep::shuffle_reveal_permutation/ipa::protocol::sort::ShuffleRevealPermutationStep::shuffle/ipa::protocol::sort::ShuffleStep::shuffle3
 ipa::protocol::prf_sharding::Step::binary_validator
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::modulus_convert_conversion_value_bits/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit100
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit101
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit102
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit103
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit104
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit105
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit106
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit107
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit108
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit109
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit110
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit111
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit112
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit113
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit114
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit115
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit116
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit117
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit118
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit119
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit120
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit121
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit122
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit123
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit124
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit125
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit126
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit127
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit32
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit33
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit34
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit35
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit36
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit37
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit38
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit39
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit40
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit41
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit42
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit43
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit44
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit45
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit46
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit47
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit48
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit49
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit50
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit51
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit52
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit53
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit54
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit55
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit56
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit57
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit58
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit59
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit60
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit61
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit62
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit63
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit64
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit65
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit66
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit67
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit68
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit69
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit70
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit71
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit72
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit73
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit74
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit75
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit76
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit77
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit78
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit79
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit80
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit81
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit82
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit83
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit84
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit85
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit86
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit87
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit88
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit89
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit90
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit91
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit92
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit93
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit94
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit95
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit96
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit97
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit98
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit99
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit32
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit33
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit34
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit35
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit36
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit37
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit38
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit39
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit40
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit41
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit42
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit43
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit44
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit45
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit46
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit47
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit48
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit49
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit50
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit51
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit52
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit53
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit54
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit55
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit56
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit57
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit58
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit59
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit60
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit61
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit62
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit63
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth7
-ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth7/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
@@ -9481,3 +9125,358 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::prime_field_validator
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit0/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit1/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit10/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit11
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit2/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit3/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit4/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit5/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit6/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit7/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit8/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::upgrade/ipa::protocol::context::semi_honest::UpgradeStep::upgrade_semi_honest/ipa::protocol::context::upgrade::UpgradeTripleStep::upgrade_bit_triple2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::modulus_convert_breakdown_key_bits_and_trigger_values/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::convert_bit9/ipa::protocol::modulus_conversion::convert_shares::ConvertSharesStep::xor2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit100
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit101
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit102
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit103
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit104
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit105
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit106
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit107
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit108
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit109
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit110
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit111
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit112
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit113
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit114
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit115
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit116
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit117
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit118
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit119
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit120
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit121
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit122
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit123
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit124
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit125
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit126
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit127
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit32
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit33
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit34
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit35
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit36
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit37
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit38
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit39
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit40
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit41
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit42
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit43
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit44
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit45
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit46
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit47
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit48
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit49
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit50
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit51
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit52
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit53
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit54
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit55
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit56
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit57
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit58
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit59
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit60
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit61
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit62
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit63
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit64
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit65
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit66
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit67
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit68
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit69
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit70
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit71
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit72
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit73
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit74
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit75
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit76
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit77
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit78
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit79
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit80
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit81
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit82
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit83
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit84
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit85
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit86
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit87
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit88
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit89
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit90
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit91
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit92
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit93
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit94
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit95
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit96
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit97
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit98
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth0/ipa::protocol::prf_sharding::bucket::BucketStep::bit99
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit32
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit33
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit34
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit35
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit36
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit37
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit38
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit39
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit40
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit41
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit42
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit43
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit44
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit45
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit46
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit47
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit48
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit49
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit50
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit51
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit52
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit53
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit54
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit55
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit56
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit57
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit58
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit59
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit60
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit61
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit62
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit63
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth1/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit16
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit17
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit18
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit19
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit20
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit21
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit22
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit23
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit24
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit25
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit26
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit27
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit28
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit29
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit30
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit31
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth2/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit10
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit11
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit12
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit13
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit14
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit15
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit8
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth3/ipa::protocol::prf_sharding::bucket::BucketStep::bit9
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit4
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit5
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit6
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth4/ipa::protocol::prf_sharding::bucket::BucketStep::bit7
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit2
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth5/ipa::protocol::prf_sharding::bucket::BucketStep::bit3
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6/ipa::protocol::prf_sharding::bucket::BucketStep::bit0
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth6/ipa::protocol::prf_sharding::bucket::BucketStep::bit1
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth7
+ipa::protocol::prf_sharding::Step::prime_field_validator/ipa::protocol::prf_sharding::Step::move_value_to_correct_breakdown/ipa::protocol::prf_sharding::BinaryTreeDepthStep::depth7/ipa::protocol::prf_sharding::bucket::BucketStep::bit0

From 055eae8ac82621610bec628e8c1814a532c94914 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 17:16:58 +0800
Subject: [PATCH 089/105] hack to avoid stall in infra

---
 src/protocol/prf_sharding/mod.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 62b4cf08d..9763ab0f6 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -459,15 +459,16 @@ where
     }));
 
     // Execute all of the async futures (sequentially), and flatten the result
-    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
-        .flat_map(|x| stream_iter(x.unwrap()));
+    let collected_per_user_results = stream_of_per_user_circuits.collect::<Vec<_>>().await;
+    let per_user_attribution_outputs = sh_ctx.parallel_join(collected_per_user_results).await?;
+    let flattenned_stream = per_user_attribution_outputs.into_iter().flatten();
 
     // modulus convert breakdown keys and trigger values
     let converted_bks_and_tvs = convert_bits(
         prime_field_ctx
             .narrow(&Step::ModulusConvertBreakdownKeyBitsAndTriggerValues)
             .set_total_records(num_outputs),
-        flattenned_stream,
+        stream_iter(flattenned_stream),
         0..BK::BITS + TV::BITS,
     );
 

From 8f45740e106e6832e324dee866a8cf96cbd9a3ca Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Thu, 2 Nov 2023 17:41:48 +0800
Subject: [PATCH 090/105] Another hack

---
 src/protocol/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index cc0ae5ab8..b1793d784 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -21,13 +21,13 @@ pub use basics::BasicProtocols;
 
 use crate::{
     error::Error,
-    ff::{Gf20Bit, Gf3Bit, Gf40Bit, Gf8Bit},
+    ff::{Gf3Bit, Gf40Bit, Gf8Bit, Gf32Bit},
 };
 
 pub type MatchKey = Gf40Bit;
 pub type BreakdownKey = Gf8Bit;
 pub type TriggerValue = Gf3Bit;
-pub type Timestamp = Gf20Bit;
+pub type Timestamp = Gf32Bit;
 
 /// Unique identifier of the MPC query requested by report collectors
 /// TODO(615): Generating this unique id may be tricky as it may involve communication between helpers and

From 04b348c9dbfda533d518c5df0bb86845a881c2a2 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Thu, 2 Nov 2023 11:42:43 -0700
Subject: [PATCH 091/105] Fix formatting

---
 src/protocol/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index b1793d784..387c059c1 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -21,7 +21,7 @@ pub use basics::BasicProtocols;
 
 use crate::{
     error::Error,
-    ff::{Gf3Bit, Gf40Bit, Gf8Bit, Gf32Bit},
+    ff::{Gf32Bit, Gf3Bit, Gf40Bit, Gf8Bit},
 };
 
 pub type MatchKey = Gf40Bit;

From c9f3d58a965d566c59ca7c493ca8a18f5b576096 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <akoshelev@users.noreply.github.com>
Date: Fri, 3 Nov 2023 13:24:39 -0700
Subject: [PATCH 092/105] Add OPRF root step to compact (#830)

* Add OPRF root step to compact

was getting an error running OPRF IPA with compact steps enabled

```
cannot narrow from the invalid step oprf_ipa
stack trace:
```

* Fix a compile bug inside compact map

* Reorder constants and fix the step number for OPRF
---
 src/protocol/step/compact.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/protocol/step/compact.rs b/src/protocol/step/compact.rs
index 585ce2042..32cdc1886 100644
--- a/src/protocol/step/compact.rs
+++ b/src/protocol/step/compact.rs
@@ -34,15 +34,17 @@ impl Debug for Compact {
 }
 
 const ROOT_STATE: u16 = 0;
-const PRSS_EXCHANGE_STATE: u16 = 65531;
 const QUERY_TYPE_SEMIHONEST_STATE: u16 = 65533;
 const QUERY_TYPE_MALICIOUS_STATE: u16 = 65532;
+const PRSS_EXCHANGE_STATE: u16 = 65531;
+const QUERY_TYPE_OPRF_STATE: u16 = 65530;
 
 impl StepNarrow<QueryType> for Compact {
     fn narrow(&self, step: &QueryType) -> Self {
         match step {
             QueryType::SemiHonestIpa(_) => Self(QUERY_TYPE_SEMIHONEST_STATE),
             QueryType::MaliciousIpa(_) => Self(QUERY_TYPE_MALICIOUS_STATE),
+            QueryType::OprfIpa(_) => Self(QUERY_TYPE_OPRF_STATE),
             _ => panic!("cannot narrow from the invalid step {}", step.as_ref()),
         }
     }
@@ -60,6 +62,7 @@ fn static_reverse_state_map(state: u16) -> &'static str {
         ROOT_STATE => "run-0",
         QUERY_TYPE_SEMIHONEST_STATE => QueryType::SEMIHONEST_IPA_STR,
         QUERY_TYPE_MALICIOUS_STATE => QueryType::MALICIOUS_IPA_STR,
+        QUERY_TYPE_OPRF_STATE => QueryType::OPRF_IPA_STR,
         PRSS_EXCHANGE_STATE => PrssExchangeStep.as_ref(),
         _ => panic!("cannot as_ref() from the invalid state {state}"),
     }
@@ -72,6 +75,8 @@ fn static_deserialize_state_map(s: &str) -> u16 {
         return QUERY_TYPE_SEMIHONEST_STATE;
     } else if s == QueryType::MALICIOUS_IPA_STR {
         return QUERY_TYPE_MALICIOUS_STATE;
+    } else if s == QueryType::OPRF_IPA_STR {
+        return QUERY_TYPE_OPRF_STATE;
     } else if s == PrssExchangeStep.as_ref() {
         return PRSS_EXCHANGE_STATE;
     }

From bd45af4cb86e4966c32de21606ee701db316e868 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <akoshelev@users.noreply.github.com>
Date: Fri, 3 Nov 2023 13:24:39 -0700
Subject: [PATCH 093/105] Add OPRF root step to compact (#830)

* Add OPRF root step to compact

was getting an error running OPRF IPA with compact steps enabled

```
cannot narrow from the invalid step oprf_ipa
stack trace:
```

* Fix a compile bug inside compact map

* Reorder constants and fix the step number for OPRF
---
 benches/oneshot/ipa.rs        |   19 +-
 src/protocol/step/compact.rs  |    7 +-
 src/protocol/step/steps.txt   | 6240 +++++++++++++++++++++++++++++++++
 src/test_fixture/event_gen.rs |   37 +-
 4 files changed, 6278 insertions(+), 25 deletions(-)

diff --git a/benches/oneshot/ipa.rs b/benches/oneshot/ipa.rs
index c597b7e29..7b86af1a9 100644
--- a/benches/oneshot/ipa.rs
+++ b/benches/oneshot/ipa.rs
@@ -1,5 +1,5 @@
 use std::{
-    num::{NonZeroU32, NonZeroUsize},
+    num::{NonZeroU32, NonZeroU64, NonZeroUsize},
     time::Instant,
 };
 
@@ -111,16 +111,29 @@ async fn run(args: Args) -> Result<(), Error> {
         q = args.query_size
     );
     let rng = StdRng::seed_from_u64(seed);
+    let (user_count, max_events_per_user, query_size) = if args.oprf && cfg!(feature = "step-trace")
+    {
+        // For the steps collection, OPRF mode requires a single user with the same number
+        // of dynamic steps as defined for `UserNthRowStep::Row`.
+        (NonZeroU64::new(1).unwrap(), 64, 64)
+    } else {
+        (
+            EventGeneratorConfig::default().user_count,
+            args.records_per_user,
+            args.query_size,
+        )
+    };
     let raw_data = EventGenerator::with_config(
         rng,
         EventGeneratorConfig {
+            user_count,
             max_trigger_value: NonZeroU32::try_from(args.max_trigger_value).unwrap(),
             max_breakdown_key: NonZeroU32::try_from(args.breakdown_keys).unwrap(),
-            max_events_per_user: NonZeroU32::try_from(args.records_per_user).unwrap(),
+            max_events_per_user: NonZeroU32::try_from(max_events_per_user).unwrap(),
             ..Default::default()
         },
     )
-    .take(args.query_size)
+    .take(query_size)
     .collect::<Vec<_>>();
 
     let order = if args.oprf {
diff --git a/src/protocol/step/compact.rs b/src/protocol/step/compact.rs
index 585ce2042..32cdc1886 100644
--- a/src/protocol/step/compact.rs
+++ b/src/protocol/step/compact.rs
@@ -34,15 +34,17 @@ impl Debug for Compact {
 }
 
 const ROOT_STATE: u16 = 0;
-const PRSS_EXCHANGE_STATE: u16 = 65531;
 const QUERY_TYPE_SEMIHONEST_STATE: u16 = 65533;
 const QUERY_TYPE_MALICIOUS_STATE: u16 = 65532;
+const PRSS_EXCHANGE_STATE: u16 = 65531;
+const QUERY_TYPE_OPRF_STATE: u16 = 65530;
 
 impl StepNarrow<QueryType> for Compact {
     fn narrow(&self, step: &QueryType) -> Self {
         match step {
             QueryType::SemiHonestIpa(_) => Self(QUERY_TYPE_SEMIHONEST_STATE),
             QueryType::MaliciousIpa(_) => Self(QUERY_TYPE_MALICIOUS_STATE),
+            QueryType::OprfIpa(_) => Self(QUERY_TYPE_OPRF_STATE),
             _ => panic!("cannot narrow from the invalid step {}", step.as_ref()),
         }
     }
@@ -60,6 +62,7 @@ fn static_reverse_state_map(state: u16) -> &'static str {
         ROOT_STATE => "run-0",
         QUERY_TYPE_SEMIHONEST_STATE => QueryType::SEMIHONEST_IPA_STR,
         QUERY_TYPE_MALICIOUS_STATE => QueryType::MALICIOUS_IPA_STR,
+        QUERY_TYPE_OPRF_STATE => QueryType::OPRF_IPA_STR,
         PRSS_EXCHANGE_STATE => PrssExchangeStep.as_ref(),
         _ => panic!("cannot as_ref() from the invalid state {state}"),
     }
@@ -72,6 +75,8 @@ fn static_deserialize_state_map(s: &str) -> u16 {
         return QUERY_TYPE_SEMIHONEST_STATE;
     } else if s == QueryType::MALICIOUS_IPA_STR {
         return QUERY_TYPE_MALICIOUS_STATE;
+    } else if s == QueryType::OPRF_IPA_STR {
+        return QUERY_TYPE_OPRF_STATE;
     } else if s == PrssExchangeStep.as_ref() {
         return PRSS_EXCHANGE_STATE;
     }
diff --git a/src/protocol/step/steps.txt b/src/protocol/step/steps.txt
index c5bafcded..743740a38 100644
--- a/src/protocol/step/steps.txt
+++ b/src/protocol/step/steps.txt
@@ -9273,6 +9273,1046 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row1/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row10/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row11/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row12/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row13/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row14/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row15/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row16/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row17/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row18/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row19/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
@@ -9377,6 +10417,1046 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row2/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row20/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row21/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row22/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row23/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row24/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row25/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row26/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row27/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row28/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row29/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
@@ -9481,3 +11561,4163 @@ ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding:
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
 ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row3/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row30/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row31/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row32/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row33/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row34/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row35/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row36/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row37/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row38/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row39/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row4/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row40/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row41/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row42/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row43/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row44/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row45/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row46/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row47/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row48/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row49/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row5/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row50/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row51/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row52/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row53/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row54/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row55/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row56/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row57/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row58/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row59/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row6/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row60/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row61/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row62/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row63/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row7/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row8/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_breakdown_key/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::attributed_event_check_flag
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::dot_product
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compare_time_delta_to_attribution_window/ipa::protocol::boolean::comparison::Step::prefix_or/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::check_attribution_window/ipa::protocol::prf_sharding::Step::compute_time_delta/ipa::protocol::step::BitOpStep::bit9
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::prf_sharding::Step::did_trigger_get_attributed
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::attributed_trigger_value/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_difference_to_cap
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_difference_to_cap/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::compute_saturating_sum/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_just_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::computed_capped_attributed_trigger_value_not_saturated_case/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::ever_encountered_source_event
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::is_saturated_and_prev_row_not_saturated
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit0
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit1
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit10
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit11
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit12
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit13
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit14
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit15
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit16
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit17
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit18
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit19
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit2
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit3
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit4
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit5
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit6
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit7
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit8
+ipa::protocol::prf_sharding::Step::binary_validator/ipa::protocol::prf_sharding::UserNthRowStep::row9/ipa::protocol::prf_sharding::Step::source_event_timestamp/ipa::protocol::step::BitOpStep::bit9
diff --git a/src/test_fixture/event_gen.rs b/src/test_fixture/event_gen.rs
index 23f995a7e..8b9651425 100644
--- a/src/test_fixture/event_gen.rs
+++ b/src/test_fixture/event_gen.rs
@@ -38,7 +38,7 @@ pub enum ReportFilter {
 #[cfg_attr(feature = "clap", derive(clap::Args))]
 pub struct Config {
     #[cfg_attr(feature = "clap", arg(long, default_value = "1000000000000"))]
-    pub max_user_id: NonZeroU64,
+    pub user_count: NonZeroU64,
     #[cfg_attr(feature = "clap", arg(long, default_value = "5"))]
     pub max_trigger_value: NonZeroU32,
     #[cfg_attr(feature = "clap", arg(long, default_value = "20"))]
@@ -77,13 +77,13 @@ impl Config {
     /// If any argument is 0.
     #[must_use]
     pub fn new(
-        max_user_id: u64,
+        user_count: u64,
         max_trigger_value: u32,
         max_breakdown_key: u32,
         max_events_per_user: u32,
     ) -> Self {
         Self {
-            max_user_id: NonZeroU64::try_from(max_user_id).unwrap(),
+            user_count: NonZeroU64::try_from(user_count).unwrap(),
             max_trigger_value: NonZeroU32::try_from(max_trigger_value).unwrap(),
             max_breakdown_key: NonZeroU32::try_from(max_breakdown_key).unwrap(),
             max_events_per_user: NonZeroU32::try_from(max_events_per_user).unwrap(),
@@ -92,8 +92,8 @@ impl Config {
         }
     }
 
-    fn max_user_id(&self) -> usize {
-        usize::try_from(self.max_user_id.get()).unwrap()
+    fn user_count(&self) -> usize {
+        usize::try_from(self.user_count.get()).unwrap()
     }
 }
 
@@ -138,8 +138,7 @@ pub struct EventGenerator<R: Rng> {
     config: Config,
     rng: R,
     users: Vec<UserStats>,
-    // even bit vector takes too long to initialize for MAX_USER_ID. Need a sparse structure
-    // here
+    // even bit vector takes too long to initialize. Need a sparse structure here
     used: HashSet<UserId>,
     current_ts: u64,
 }
@@ -214,7 +213,7 @@ impl<R: Rng> EventGenerator<R> {
     }
 
     fn sample_user(&mut self) -> Option<UserStats> {
-        if self.used.len() == self.config.max_user_id() {
+        if self.used.len() == self.config.user_count() {
             return None;
         }
 
@@ -223,15 +222,11 @@ impl<R: Rng> EventGenerator<R> {
         Some(loop {
             let next = UserId::from(
                 self.rng
-                    .gen_range(UserId::FIRST.into()..=self.config.max_user_id.get()),
+                    .gen_range(UserId::FIRST.into()..=self.config.user_count.get()),
             );
             if valid(next) {
                 self.used.insert(next);
-                break UserStats::new(
-                    next,
-                    self.rng
-                        .gen_range(1..=self.config.max_events_per_user.get()),
-                );
+                break UserStats::new(next, self.config.max_events_per_user.get());
             }
         })
     }
@@ -281,18 +276,18 @@ mod tests {
 
     #[test]
     fn exhaust() {
-        let mut gen = EventGenerator::with_config(
+        let gen = EventGenerator::with_config(
             thread_rng(),
             Config {
-                max_user_id: NonZeroU64::new(2).unwrap(),
-                max_events_per_user: NonZeroU32::new(1).unwrap(),
+                user_count: NonZeroU64::new(10).unwrap(),
+                max_events_per_user: NonZeroU32::new(10).unwrap(),
                 ..Config::default()
             },
         );
 
-        assert!(gen.next().is_some());
-        assert!(gen.next().is_some());
-        assert!(gen.next().is_none());
+        let mut iter = gen.skip(99);
+        assert!(iter.next().is_some());
+        assert!(iter.next().is_none());
     }
 
     mod proptests {
@@ -367,7 +362,7 @@ mod tests {
                 .prop_map(
                     |(max_trigger_value, max_breakdown_key, max_events_per_user, report_filter)| {
                         Config {
-                            max_user_id: NonZeroU64::new(10_000).unwrap(),
+                            user_count: NonZeroU64::new(10_000).unwrap(),
                             max_trigger_value: NonZeroU32::new(max_trigger_value).unwrap(),
                             max_breakdown_key: NonZeroU32::new(max_breakdown_key).unwrap(),
                             max_events_per_user: NonZeroU32::new(max_events_per_user).unwrap(),

From 50a627695b0638521ca2166719b263b15eef4536 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Tue, 7 Nov 2023 00:35:56 +0800
Subject: [PATCH 094/105] Trying to debug why this is still stuck

---
 src/protocol/prf_sharding/mod.rs | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index 9763ab0f6..a52cb980f 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -103,6 +103,7 @@ impl InputsRequiredFromPrevRow {
     pub async fn compute_row_with_previous<C, BK, TV, TS>(
         &mut self,
         ctx: C,
+        depth: usize,
         record_id: RecordId,
         input_row: &PrfShardedIpaInputRow<BK, TV, TS>,
         num_saturating_sum_bits: usize,
@@ -114,6 +115,7 @@ impl InputsRequiredFromPrevRow {
         TV: GaloisField,
         TS: GaloisField,
     {
+        println!("depth: {}, record_id: {}", depth, usize::from(record_id));
         let (bd_key, tv, timestamp) = (
             input_row.breakdown_key_bits(),
             input_row.trigger_value_bits(),
@@ -349,6 +351,8 @@ where
 ///
 /// Takes an input stream of `PrfShardedIpaInputRecordRow` which is assumed to have all records with a given PRF adjacent
 /// and converts it into a stream of vectors of `PrfShardedIpaInputRecordRow` having the same PRF.
+/// 
+/// Filters out any users that only have a single row, since they will produce no attributed conversions.
 ///
 fn chunk_rows_by_user<IS, BK, TV, TS>(
     input_stream: IS,
@@ -362,13 +366,18 @@ where
 {
     unfold(Some((input_stream, first_row)), |state| async move {
         let (mut s, last_row) = state?;
-        let last_row_prf = last_row.prf_of_match_key;
+        let mut last_row_prf = last_row.prf_of_match_key;
         let mut current_chunk = vec![last_row];
         while let Some(row) = s.next().await {
             if row.prf_of_match_key == last_row_prf {
                 current_chunk.push(row);
             } else {
-                return Some((current_chunk, Some((s, row))));
+                if current_chunk.len() > 1 {
+                    return Some((current_chunk, Some((s, row))));
+                } else {
+                    last_row_prf = row.prf_of_match_key;
+                    current_chunk = vec![row];
+                }
             }
         }
         Some((current_chunk, None))
@@ -414,6 +423,8 @@ where
     assert!(BK::BITS > 0);
     assert!(TS::BITS > 0);
 
+    println!("histogram: {:?}", histogram);
+
     // Get the validator and context to use for Gf2 multiplication operations
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
@@ -459,16 +470,15 @@ where
     }));
 
     // Execute all of the async futures (sequentially), and flatten the result
-    let collected_per_user_results = stream_of_per_user_circuits.collect::<Vec<_>>().await;
-    let per_user_attribution_outputs = sh_ctx.parallel_join(collected_per_user_results).await?;
-    let flattenned_stream = per_user_attribution_outputs.into_iter().flatten();
+    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
+        .flat_map(|x| stream_iter(x.unwrap()));
 
     // modulus convert breakdown keys and trigger values
     let converted_bks_and_tvs = convert_bits(
         prime_field_ctx
             .narrow(&Step::ModulusConvertBreakdownKeyBitsAndTriggerValues)
             .set_total_records(num_outputs),
-        stream_iter(flattenned_stream),
+        flattenned_stream,
         0..BK::BITS + TV::BITS,
     );
 
@@ -544,6 +554,7 @@ where
         let capped_attribution_outputs = prev_row_inputs
             .compute_row_with_previous(
                 ctx_for_this_row_depth,
+                i,
                 record_id_for_this_row_depth,
                 row,
                 num_saturating_sum_bits,

From 57c3e2f2dcf7f771e07629a6c1dad1dfd951eb1f Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Tue, 7 Nov 2023 00:38:29 +0800
Subject: [PATCH 095/105] Revert "Trying to debug why this is still stuck"

This reverts commit 50a627695b0638521ca2166719b263b15eef4536.
---
 src/protocol/prf_sharding/mod.rs | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/prf_sharding/mod.rs
index a52cb980f..9763ab0f6 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/prf_sharding/mod.rs
@@ -103,7 +103,6 @@ impl InputsRequiredFromPrevRow {
     pub async fn compute_row_with_previous<C, BK, TV, TS>(
         &mut self,
         ctx: C,
-        depth: usize,
         record_id: RecordId,
         input_row: &PrfShardedIpaInputRow<BK, TV, TS>,
         num_saturating_sum_bits: usize,
@@ -115,7 +114,6 @@ impl InputsRequiredFromPrevRow {
         TV: GaloisField,
         TS: GaloisField,
     {
-        println!("depth: {}, record_id: {}", depth, usize::from(record_id));
         let (bd_key, tv, timestamp) = (
             input_row.breakdown_key_bits(),
             input_row.trigger_value_bits(),
@@ -351,8 +349,6 @@ where
 ///
 /// Takes an input stream of `PrfShardedIpaInputRecordRow` which is assumed to have all records with a given PRF adjacent
 /// and converts it into a stream of vectors of `PrfShardedIpaInputRecordRow` having the same PRF.
-/// 
-/// Filters out any users that only have a single row, since they will produce no attributed conversions.
 ///
 fn chunk_rows_by_user<IS, BK, TV, TS>(
     input_stream: IS,
@@ -366,18 +362,13 @@ where
 {
     unfold(Some((input_stream, first_row)), |state| async move {
         let (mut s, last_row) = state?;
-        let mut last_row_prf = last_row.prf_of_match_key;
+        let last_row_prf = last_row.prf_of_match_key;
         let mut current_chunk = vec![last_row];
         while let Some(row) = s.next().await {
             if row.prf_of_match_key == last_row_prf {
                 current_chunk.push(row);
             } else {
-                if current_chunk.len() > 1 {
-                    return Some((current_chunk, Some((s, row))));
-                } else {
-                    last_row_prf = row.prf_of_match_key;
-                    current_chunk = vec![row];
-                }
+                return Some((current_chunk, Some((s, row))));
             }
         }
         Some((current_chunk, None))
@@ -423,8 +414,6 @@ where
     assert!(BK::BITS > 0);
     assert!(TS::BITS > 0);
 
-    println!("histogram: {:?}", histogram);
-
     // Get the validator and context to use for Gf2 multiplication operations
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
@@ -470,15 +459,16 @@ where
     }));
 
     // Execute all of the async futures (sequentially), and flatten the result
-    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
-        .flat_map(|x| stream_iter(x.unwrap()));
+    let collected_per_user_results = stream_of_per_user_circuits.collect::<Vec<_>>().await;
+    let per_user_attribution_outputs = sh_ctx.parallel_join(collected_per_user_results).await?;
+    let flattenned_stream = per_user_attribution_outputs.into_iter().flatten();
 
     // modulus convert breakdown keys and trigger values
     let converted_bks_and_tvs = convert_bits(
         prime_field_ctx
             .narrow(&Step::ModulusConvertBreakdownKeyBitsAndTriggerValues)
             .set_total_records(num_outputs),
-        flattenned_stream,
+        stream_iter(flattenned_stream),
         0..BK::BITS + TV::BITS,
     );
 
@@ -554,7 +544,6 @@ where
         let capped_attribution_outputs = prev_row_inputs
             .compute_row_with_previous(
                 ctx_for_this_row_depth,
-                i,
                 record_id_for_this_row_depth,
                 row,
                 num_saturating_sum_bits,

From c5b59f8c89adca951fd5565caef7c9fd5d3ab5aa Mon Sep 17 00:00:00 2001
From: danielmasny <46358615+danielmasny@users.noreply.github.com>
Date: Mon, 6 Nov 2023 11:57:36 -0800
Subject: [PATCH 096/105] Add PRF evaluation circuit (#833)

Evaluating OPRF requires using a new field, so this change adds a bunch of integration with curve-25519

---------

Co-authored-by: Daniel Masny <dmasny@fb.com>
Co-authored-by: Alex Koshelev <akoshelev@users.noreply.github.com>
Co-authored-by: Alex Koshelev <koshelev@meta.com>
---
 Cargo.toml                                    |   6 +-
 src/error.rs                                  |   2 +
 src/ff/curve_points.rs                        | 239 ++++++++++++++++
 src/ff/ec_prime_field.rs                      | 269 ++++++++++++++++++
 src/ff/mod.rs                                 |   2 +
 src/helpers/mod.rs                            |   4 +-
 src/protocol/basics/reveal.rs                 |   4 +-
 src/protocol/ipa_prf/mod.rs                   |   3 +
 src/protocol/ipa_prf/prf_eval.rs              | 198 +++++++++++++
 .../{ => ipa_prf}/prf_sharding/bucket.rs      |   5 +-
 .../prf_sharding/feature_label_dot_product.rs |   2 +-
 .../{ => ipa_prf}/prf_sharding/mod.rs         |   7 +-
 src/protocol/mod.rs                           |   2 +-
 src/query/runner/oprf_ipa.rs                  |   2 +-
 src/report.rs                                 |   2 +-
 src/secret_sharing/mod.rs                     |  49 +++-
 src/secret_sharing/replicated/mod.rs          |   4 +-
 .../replicated/semi_honest/additive_share.rs  |  44 +--
 src/secret_sharing/scheme.rs                  |   4 +-
 src/test_fixture/ipa.rs                       |   4 +-
 20 files changed, 798 insertions(+), 54 deletions(-)
 create mode 100644 src/ff/curve_points.rs
 create mode 100644 src/ff/ec_prime_field.rs
 create mode 100644 src/protocol/ipa_prf/mod.rs
 create mode 100644 src/protocol/ipa_prf/prf_eval.rs
 rename src/protocol/{ => ipa_prf}/prf_sharding/bucket.rs (98%)
 rename src/protocol/{ => ipa_prf}/prf_sharding/feature_label_dot_product.rs (99%)
 rename src/protocol/{ => ipa_prf}/prf_sharding/mod.rs (99%)

diff --git a/Cargo.toml b/Cargo.toml
index 1767e8e24..f65c44f08 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,8 @@ default = [
     "tracing/max_level_trace",
     "tracing/release_max_level_info",
     "descriptive-gate",
-    "aggregate-circuit"
+    "aggregate-circuit",
+    "ipa-prf"
 ]
 cli = ["comfy-table", "clap"]
 enable-serde = ["serde", "serde_json"]
@@ -41,6 +42,8 @@ compact-gate = ["ipa-macros/compact-gate"]
 # Standalone aggregation protocol. We use IPA infra for communication
 # but it has nothing to do with IPA.
 aggregate-circuit = []
+# IPA protocol based on OPRF
+ipa-prf = []
 
 [dependencies]
 aes = "0.8.3"
@@ -54,6 +57,7 @@ clap = { version = "4.3.2", optional = true, features = ["derive"] }
 comfy-table = { version = "7.0", optional = true }
 config = "0.13.2"
 criterion = { version = "0.5.1", optional = true, default-features = false, features = ["async_tokio", "plotters", "html_reports"] }
+curve25519-dalek = "4.1.1"
 dashmap = "5.4"
 dhat = "0.3.2"
 embed-doc-image = "0.1.4"
diff --git a/src/error.rs b/src/error.rs
index c68b325a8..de41eda4b 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -58,6 +58,8 @@ pub enum Error {
     InvalidReport(#[from] InvalidReportError),
     #[error("unsupported: {0}")]
     Unsupported(String),
+    #[error("Decompressing invalid elliptic curve point: {0}")]
+    DecompressingInvalidCurvePoint(String),
 }
 
 impl Default for Error {
diff --git a/src/ff/curve_points.rs b/src/ff/curve_points.rs
new file mode 100644
index 000000000..8eaa57623
--- /dev/null
+++ b/src/ff/curve_points.rs
@@ -0,0 +1,239 @@
+use curve25519_dalek::{
+    ristretto::{CompressedRistretto, RistrettoPoint},
+    Scalar,
+};
+use generic_array::GenericArray;
+use typenum::U32;
+
+use crate::{
+    ff::{ec_prime_field::Fp25519, Serializable},
+    secret_sharing::{Block, WeakSharedValue},
+};
+
+impl Block for CompressedRistretto {
+    type Size = U32;
+}
+
+///ristretto point for curve 25519,
+/// we store it in compressed format since it is 3 times smaller and we do a limited amount of
+/// arithmetic operations on the curve points
+///
+/// We use ristretto points such that we have a prime order elliptic curve,
+/// This is needed for the Dodis Yampolski PRF
+///
+/// decompressing invalid curve points will cause panics,
+/// since we always generate curve points from scalars (elements in Fp25519) and
+/// only deserialize previously serialized valid points, panics will not occur
+/// However, we still added a debug assert to deserialize since values are sent by other servers
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct RP25519(CompressedRistretto);
+
+/// Implementing trait for secret sharing
+impl WeakSharedValue for RP25519 {
+    type Storage = CompressedRistretto;
+    const BITS: u32 = 256;
+    const ZERO: Self = Self(CompressedRistretto([0_u8; 32]));
+}
+
+impl Serializable for RP25519 {
+    type Size = <<RP25519 as WeakSharedValue>::Storage as Block>::Size;
+
+    fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
+        *buf.as_mut() = self.0.to_bytes();
+    }
+
+    fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
+        debug_assert!(CompressedRistretto((*buf).into()).decompress().is_some());
+        RP25519(CompressedRistretto((*buf).into()))
+    }
+}
+
+///## Panics
+/// Panics when decompressing invalid curve point. This can happen when deserialize curve point
+/// from bit array that does not have a valid representation on the curve
+impl std::ops::Add for RP25519 {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self((self.0.decompress().unwrap() + rhs.0.decompress().unwrap()).compress())
+    }
+}
+
+impl std::ops::AddAssign for RP25519 {
+    #[allow(clippy::assign_op_pattern)]
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs;
+    }
+}
+
+///## Panics
+/// Panics when decompressing invalid curve point. This can happen when deserialize curve point
+/// from bit array that does not have a valid representation on the curve
+impl std::ops::Neg for RP25519 {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(self.0.decompress().unwrap().neg().compress())
+    }
+}
+
+///## Panics
+/// Panics when decompressing invalid curve point. This can happen when deserialize curve point
+/// from bit array that does not have a valid representation on the curve
+impl std::ops::Sub for RP25519 {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self((self.0.decompress().unwrap() - rhs.0.decompress().unwrap()).compress())
+    }
+}
+
+impl std::ops::SubAssign for RP25519 {
+    #[allow(clippy::assign_op_pattern)]
+    fn sub_assign(&mut self, rhs: Self) {
+        *self = *self - rhs;
+    }
+}
+
+///Scalar Multiplication
+/// allows to multiply curve points with scalars from Fp25519
+///## Panics
+/// Panics when decompressing invalid curve point. This can happen when deserialize curve point
+/// from bit array that does not have a valid representation on the curve
+impl std::ops::Mul<Fp25519> for RP25519 {
+    type Output = Self;
+
+    fn mul(self, rhs: Fp25519) -> RP25519 {
+        (self.0.decompress().unwrap() * Scalar::from(rhs))
+            .compress()
+            .into()
+    }
+}
+
+impl std::ops::MulAssign<Fp25519> for RP25519 {
+    #[allow(clippy::assign_op_pattern)]
+    fn mul_assign(&mut self, rhs: Fp25519) {
+        *self = *self * rhs;
+    }
+}
+
+impl From<Scalar> for RP25519 {
+    fn from(s: Scalar) -> Self {
+        RP25519(RistrettoPoint::mul_base(&s).compress())
+    }
+}
+
+impl From<Fp25519> for RP25519 {
+    fn from(s: Fp25519) -> Self {
+        RP25519(RistrettoPoint::mul_base(&s.into()).compress())
+    }
+}
+
+impl From<CompressedRistretto> for RP25519 {
+    fn from(s: CompressedRistretto) -> Self {
+        RP25519(s)
+    }
+}
+
+impl From<RP25519> for CompressedRistretto {
+    fn from(s: RP25519) -> Self {
+        s.0
+    }
+}
+
+///allows to convert curve points into unsigned integers, preserving high entropy
+macro_rules! cp_hash_impl {
+    ( $u_type:ty) => {
+        impl From<RP25519> for $u_type {
+            fn from(s: RP25519) -> Self {
+                use hkdf::Hkdf;
+                use sha2::Sha256;
+                let hk = Hkdf::<Sha256>::new(None, s.0.as_bytes());
+                let mut okm = <$u_type>::MIN.to_le_bytes();
+                //error invalid length from expand only happens when okm is very large
+                hk.expand(&[], &mut okm).unwrap();
+                <$u_type>::from_le_bytes(okm)
+            }
+        }
+    };
+}
+
+cp_hash_impl!(u128);
+
+cp_hash_impl!(u64);
+
+/// implementing random curve point generation for testing purposes,
+/// in the actual IPA protocol, we generate them from scalars, i.e. Fp25519
+#[cfg(test)]
+impl rand::distributions::Distribution<RP25519> for rand::distributions::Standard {
+    fn sample<R: crate::rand::Rng + ?Sized>(&self, rng: &mut R) -> RP25519 {
+        let mut scalar_bytes = [0u8; 64];
+        rng.fill_bytes(&mut scalar_bytes);
+        RP25519(RistrettoPoint::from_uniform_bytes(&scalar_bytes).compress())
+    }
+}
+
+#[cfg(all(test, unit_test))]
+mod test {
+    use curve25519_dalek::{constants, scalar::Scalar};
+    use generic_array::GenericArray;
+    use rand::{thread_rng, Rng};
+    use typenum::U32;
+
+    use crate::{
+        ff::{curve_points::RP25519, ec_prime_field::Fp25519, Serializable},
+        secret_sharing::WeakSharedValue,
+    };
+
+    cp_hash_impl!(u32);
+
+    ///testing serialize and deserialize
+    #[test]
+    fn serde_25519() {
+        let mut rng = thread_rng();
+        let input = rng.gen::<RP25519>();
+        let mut a: GenericArray<u8, U32> = [0u8; 32].into();
+        input.serialize(&mut a);
+        let output = RP25519::deserialize(&a);
+        assert_eq!(input, output);
+    }
+
+    ///testing conversion from scalar to Fp25519 and curve point, i.e. RP25519
+    #[test]
+    fn scalar_to_point() {
+        let a = Scalar::ONE;
+        let b: RP25519 = a.into();
+        let d: Fp25519 = a.into();
+        let c: RP25519 = RP25519::from(d);
+        assert_eq!(b, RP25519(constants::RISTRETTO_BASEPOINT_COMPRESSED));
+        assert_eq!(c, RP25519(constants::RISTRETTO_BASEPOINT_COMPRESSED));
+    }
+
+    ///testing simple curve arithmetics to check that `curve25519_dalek` library is used correctly
+    #[test]
+    fn curve_arithmetics() {
+        let mut rng = thread_rng();
+        let fp_a = rng.gen::<Fp25519>();
+        let fp_b = rng.gen::<Fp25519>();
+        let fp_c = fp_a + fp_b;
+        let fp_d = RP25519::from(fp_a) + RP25519::from(fp_b);
+        assert_eq!(fp_d, RP25519::from(fp_c));
+        assert_ne!(fp_d, RP25519(constants::RISTRETTO_BASEPOINT_COMPRESSED));
+        let fp_e = rng.gen::<Fp25519>();
+        let fp_f = rng.gen::<Fp25519>();
+        let fp_g = fp_e * fp_f;
+        let fp_h = RP25519::from(fp_e) * fp_f;
+        assert_eq!(fp_h, RP25519::from(fp_g));
+        assert_ne!(fp_h, RP25519(constants::RISTRETTO_BASEPOINT_COMPRESSED));
+        assert_eq!(RP25519::ZERO, fp_h * Scalar::ZERO.into());
+    }
+
+    ///testing curve to unsigned integer conversion has entropy (!= 0)
+    #[test]
+    fn curve_point_to_hash() {
+        let mut rng = thread_rng();
+        let fp_a = rng.gen::<RP25519>();
+        assert_ne!(0u64, u64::from(fp_a));
+        assert_ne!(0u32, u32::from(fp_a));
+    }
+}
diff --git a/src/ff/ec_prime_field.rs b/src/ff/ec_prime_field.rs
new file mode 100644
index 000000000..3385f10e8
--- /dev/null
+++ b/src/ff/ec_prime_field.rs
@@ -0,0 +1,269 @@
+use curve25519_dalek::scalar::Scalar;
+use generic_array::GenericArray;
+use hkdf::Hkdf;
+use sha2::Sha256;
+use typenum::U32;
+
+use crate::{
+    ff::{Field, Serializable},
+    secret_sharing::{Block, SharedValue},
+};
+
+impl Block for Scalar {
+    type Size = U32;
+}
+
+///implements the Scalar field for elliptic curve 25519
+/// we use elements in Fp25519 to generate curve points and operate on the curve
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub struct Fp25519(<Self as SharedValue>::Storage);
+
+impl Fp25519 {
+    pub const ONE: Self = Self(Scalar::ONE);
+
+    ///allow invert for scalars, i.e. computes 1/a mod p
+    ///# Panics
+    /// Panics when self is zero
+    #[must_use]
+    pub fn invert(&self) -> Fp25519 {
+        assert_ne!(*self, Fp25519::ZERO);
+        Fp25519(self.0.invert())
+    }
+}
+
+///trait for secret sharing
+impl SharedValue for Fp25519 {
+    type Storage = Scalar;
+    const BITS: u32 = 256;
+    const ZERO: Self = Self(Scalar::ZERO);
+}
+
+///conversion to Scalar struct of `curve25519_dalek`
+impl From<Fp25519> for Scalar {
+    fn from(s: Fp25519) -> Self {
+        s.0
+    }
+}
+
+impl Serializable for Fp25519 {
+    type Size = <<Fp25519 as SharedValue>::Storage as Block>::Size;
+
+    fn serialize(&self, buf: &mut GenericArray<u8, Self::Size>) {
+        *buf.as_mut() = self.0.to_bytes();
+    }
+
+    fn deserialize(buf: &GenericArray<u8, Self::Size>) -> Self {
+        Fp25519(Scalar::from_bytes_mod_order((*buf).into()))
+    }
+}
+
+///generate random elements in Fp25519
+impl rand::distributions::Distribution<Fp25519> for rand::distributions::Standard {
+    fn sample<R: crate::rand::Rng + ?Sized>(&self, rng: &mut R) -> Fp25519 {
+        let mut scalar_bytes = [0u8; 32];
+        rng.fill_bytes(&mut scalar_bytes);
+        Fp25519(Scalar::from_bytes_mod_order(scalar_bytes))
+    }
+}
+
+impl std::ops::Add for Fp25519 {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl std::ops::AddAssign for Fp25519 {
+    #[allow(clippy::assign_op_pattern)]
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs;
+    }
+}
+
+impl std::ops::Neg for Fp25519 {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(self.0.neg())
+    }
+}
+
+impl std::ops::Sub for Fp25519 {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl std::ops::SubAssign for Fp25519 {
+    #[allow(clippy::assign_op_pattern)]
+    fn sub_assign(&mut self, rhs: Self) {
+        *self = *self - rhs;
+    }
+}
+
+impl std::ops::Mul for Fp25519 {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}
+
+impl std::ops::MulAssign for Fp25519 {
+    #[allow(clippy::assign_op_pattern)]
+    fn mul_assign(&mut self, rhs: Self) {
+        *self = *self * rhs;
+    }
+}
+
+impl From<Scalar> for Fp25519 {
+    fn from(s: Scalar) -> Self {
+        Fp25519(s)
+    }
+}
+
+///conversion from and to unsigned integers, preserving entropy, for testing purposes only
+#[cfg(test)]
+macro_rules! sc_hash_impl {
+    ( $u_type:ty) => {
+        impl From<Fp25519> for $u_type {
+            fn from(s: Fp25519) -> Self {
+                use hkdf::Hkdf;
+                use sha2::Sha256;
+                let hk = Hkdf::<Sha256>::new(None, s.0.as_bytes());
+                let mut okm = <$u_type>::MIN.to_le_bytes();
+                //error invalid length from expand only happens when okm is very large
+                hk.expand(&[], &mut okm).unwrap();
+                <$u_type>::from_le_bytes(okm)
+            }
+        }
+
+        impl From<$u_type> for Fp25519 {
+            fn from(s: $u_type) -> Self {
+                use hkdf::Hkdf;
+                use sha2::Sha256;
+                let hk = Hkdf::<Sha256>::new(None, &s.to_le_bytes());
+                let mut okm = [0u8; 32];
+                //error invalid length from expand only happens when okm is very large
+                hk.expand(&[], &mut okm).unwrap();
+                Fp25519::deserialize(&okm.into())
+            }
+        }
+    };
+}
+
+#[cfg(test)]
+sc_hash_impl!(u64);
+
+///implement Field because required by PRSS
+impl Field for Fp25519 {
+    const ONE: Fp25519 = Fp25519::ONE;
+
+    ///both following methods are based on hashing and do not allow to actually convert elements in Fp25519
+    /// from or into u128. However it is sufficient to generate random elements in Fp25519
+    fn as_u128(&self) -> u128 {
+        let hk = Hkdf::<Sha256>::new(None, self.0.as_bytes());
+        let mut okm = [0u8; 16];
+        //error invalid length from expand only happens when okm is very large
+        hk.expand(&[], &mut okm).unwrap();
+        u128::from_le_bytes(okm)
+    }
+
+    ///PRSS uses `truncate_from function`, we need to expand the u128 using a PRG (Sha256) to a [u8;32]
+    fn truncate_from<T: Into<u128>>(v: T) -> Self {
+        let hk = Hkdf::<Sha256>::new(None, &v.into().to_le_bytes());
+        let mut okm = [0u8; 32];
+        //error invalid length from expand only happens when okm is very large
+        hk.expand(&[], &mut okm).unwrap();
+        Fp25519::deserialize(&okm.into())
+    }
+}
+
+///implement `TryFrom` since required by Field
+impl TryFrom<u128> for Fp25519 {
+    type Error = crate::error::Error;
+
+    fn try_from(v: u128) -> Result<Self, Self::Error> {
+        let mut bits = [0u8; 32];
+        bits[..].copy_from_slice(&v.to_le_bytes());
+        let f: Fp25519 = Fp25519::ONE;
+        f.serialize((&mut bits).into());
+        Ok(f)
+    }
+}
+
+#[cfg(all(test, unit_test))]
+mod test {
+    use curve25519_dalek::scalar::Scalar;
+    use generic_array::GenericArray;
+    use rand::{thread_rng, Rng};
+    use typenum::U32;
+
+    use crate::{
+        ff::{ec_prime_field::Fp25519, Serializable},
+        secret_sharing::SharedValue,
+    };
+
+    sc_hash_impl!(u32);
+
+    ///test serialize and deserialize
+    #[test]
+    fn serde_25519() {
+        let mut rng = thread_rng();
+        let input = rng.gen::<Fp25519>();
+        let mut a: GenericArray<u8, U32> = [0u8; 32].into();
+        input.serialize(&mut a);
+        let output = Fp25519::deserialize(&a);
+        assert_eq!(input, output);
+    }
+
+    ///test simple arithmetics to check that `curve25519_dalek` is used correctly
+    #[test]
+    fn simple_arithmetics_25519() {
+        let a = Fp25519(Scalar::from_bytes_mod_order([
+            0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ]));
+        let b = Fp25519(Scalar::from_bytes_mod_order([
+            0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ]));
+        let d = Fp25519(Scalar::from_bytes_mod_order([
+            0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ]));
+        let e = Fp25519(Scalar::from_bytes_mod_order([
+            0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+        ]));
+        let cc = b - a;
+        let dc = a + b;
+        let ec = a * b;
+        assert_eq!(cc, Fp25519::ONE);
+        assert_eq!(dc, d);
+        assert_eq!(ec, e);
+    }
+
+    ///test random field element generation (!= 0)
+    #[test]
+    fn simple_random_25519() {
+        let mut rng = thread_rng();
+        assert_ne!(Fp25519::ZERO, rng.gen::<Fp25519>());
+    }
+
+    ///test inversion for field elements
+    #[test]
+    fn invert_25519() {
+        let mut rng = thread_rng();
+        let a = rng.gen::<Fp25519>();
+        let ia = a.invert();
+        assert_eq!(a * ia, Fp25519(Scalar::ONE));
+    }
+}
diff --git a/src/ff/mod.rs b/src/ff/mod.rs
index 5f18196c7..1ced6caf0 100644
--- a/src/ff/mod.rs
+++ b/src/ff/mod.rs
@@ -2,6 +2,8 @@
 //
 // This is where we store arithmetic shared secret data models.
 
+pub mod curve_points;
+pub mod ec_prime_field;
 mod field;
 mod galois_field;
 mod prime_field;
diff --git a/src/helpers/mod.rs b/src/helpers/mod.rs
index 359bf305f..1c510485e 100644
--- a/src/helpers/mod.rs
+++ b/src/helpers/mod.rs
@@ -40,7 +40,7 @@ use crate::{
         Role::{H1, H2, H3},
     },
     protocol::{step::Gate, RecordId},
-    secret_sharing::SharedValue,
+    secret_sharing::WeakSharedValue,
 };
 
 // TODO work with ArrayLength only
@@ -409,7 +409,7 @@ impl Debug for ChannelId {
 pub trait Message: Debug + Send + Serializable + 'static + Sized {}
 
 /// Any shared value can be send as a message
-impl<V: SharedValue> Message for V {}
+impl<V: WeakSharedValue> Message for V {}
 
 impl Serializable for PublicKey {
     type Size = typenum::U32;
diff --git a/src/protocol/basics/reveal.rs b/src/protocol/basics/reveal.rs
index 672c8a473..9fddb65b8 100644
--- a/src/protocol/basics/reveal.rs
+++ b/src/protocol/basics/reveal.rs
@@ -18,7 +18,7 @@ use crate::{
             malicious::{AdditiveShare as MaliciousReplicated, ExtendableField},
             semi_honest::AdditiveShare as Replicated,
         },
-        SecretSharing, SharedValue,
+        SecretSharing, WeakSharedValue,
     },
 };
 
@@ -47,7 +47,7 @@ pub trait Reveal<C: Context, B: RecordBinding>: Sized {
 /// i.e. their own shares and received share.
 #[async_trait]
 #[embed_doc_image("reveal", "images/reveal.png")]
-impl<C: Context, V: SharedValue> Reveal<C, RecordId> for Replicated<V> {
+impl<C: Context, V: WeakSharedValue> Reveal<C, RecordId> for Replicated<V> {
     type Output = V;
 
     async fn reveal<'fut>(&self, ctx: C, record_id: RecordId) -> Result<V, Error>
diff --git a/src/protocol/ipa_prf/mod.rs b/src/protocol/ipa_prf/mod.rs
new file mode 100644
index 000000000..f3ee4a5f9
--- /dev/null
+++ b/src/protocol/ipa_prf/mod.rs
@@ -0,0 +1,3 @@
+#[cfg(feature = "descriptive-gate")]
+pub mod prf_eval;
+pub mod prf_sharding;
diff --git a/src/protocol/ipa_prf/prf_eval.rs b/src/protocol/ipa_prf/prf_eval.rs
new file mode 100644
index 000000000..ff37e30eb
--- /dev/null
+++ b/src/protocol/ipa_prf/prf_eval.rs
@@ -0,0 +1,198 @@
+use ipa_macros::Step;
+
+use crate::{
+    error::Error,
+    ff::{curve_points::RP25519, ec_prime_field::Fp25519},
+    protocol::{
+        basics::{Reveal, SecureMul},
+        context::Context,
+        prss::SharedRandomness,
+        RecordId,
+    },
+    secret_sharing::replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing},
+};
+
+#[derive(Step)]
+pub(crate) enum Step {
+    PRFKeyGen,
+    GenRandomMask,
+    MultMaskWithPRFInput,
+    RevealR,
+    Revealz,
+}
+
+/// generates match key pseudonyms from match keys (in Fp25519 format) and PRF key
+/// PRF key needs to be generated separately using `gen_prf_key`
+///
+/// `gen_prf_key` is not included such that `compute_match_key_pseudonym` can be tested for correctness
+/// # Errors
+/// Propagates errors from multiplications
+pub async fn compute_match_key_pseudonym<C>(
+    sh_ctx: C,
+    prf_key: AdditiveShare<Fp25519>,
+    input_match_keys: Vec<AdditiveShare<Fp25519>>,
+) -> Result<Vec<u64>, Error>
+where
+    C: Context,
+{
+    let ctx = sh_ctx.set_total_records(input_match_keys.len());
+    let futures = input_match_keys
+        .iter()
+        .enumerate()
+        .map(|(i, x)| eval_dy_prf(ctx.clone(), i.into(), &prf_key, x));
+    ctx.try_join(futures).await
+}
+
+impl From<AdditiveShare<Fp25519>> for AdditiveShare<RP25519> {
+    fn from(s: AdditiveShare<Fp25519>) -> Self {
+        AdditiveShare::new(RP25519::from(s.left()), RP25519::from(s.right()))
+    }
+}
+
+/// generates PRF key k as secret sharing over Fp25519
+pub fn gen_prf_key<C>(ctx: &C) -> AdditiveShare<Fp25519>
+where
+    C: Context,
+{
+    ctx.narrow(&Step::PRFKeyGen)
+        .prss()
+        .generate_replicated(RecordId(0))
+}
+
+/// evaluates the Dodis-Yampolski PRF g^(1/(k+x))
+/// the input x and k are secret shared over finite field Fp25519, i.e. the scalar field of curve 25519
+/// PRF key k needs to be generated using `gen_prf_key`
+///  x is the match key in Fp25519 format
+/// outputs a u64 as specified in `protocol/prf_sharding/mod.rs`, all parties learn the output
+/// # Errors
+/// Propagates errors from multiplications, reveal and scalar multiplication
+
+pub async fn eval_dy_prf<C>(
+    ctx: C,
+    record_id: RecordId,
+    k: &AdditiveShare<Fp25519>,
+    x: &AdditiveShare<Fp25519>,
+) -> Result<u64, Error>
+where
+    C: Context,
+{
+    let sh_r: AdditiveShare<Fp25519> = ctx
+        .narrow(&Step::GenRandomMask)
+        .prss()
+        .generate_replicated(record_id);
+
+    //compute (g^left, g^right)
+    let sh_gr = AdditiveShare::<RP25519>::from(sh_r.clone());
+
+    //compute x+k
+    let mut y = x + k;
+
+    //compute y <- r*y
+    y = y
+        .multiply(&sh_r, ctx.narrow(&Step::MultMaskWithPRFInput), record_id)
+        .await?;
+
+    //reconstruct (z,R)
+    let gr: RP25519 = sh_gr.reveal(ctx.narrow(&Step::RevealR), record_id).await?;
+    let z = y.reveal(ctx.narrow(&Step::Revealz), record_id).await?;
+
+    //compute R^(1/z) to u64
+    Ok(u64::from(gr * (z.invert())))
+}
+
+#[cfg(all(test, unit_test))]
+mod test {
+    use rand::Rng;
+
+    use crate::{
+        ff::{curve_points::RP25519, ec_prime_field::Fp25519},
+        protocol::ipa_prf::prf_eval::compute_match_key_pseudonym,
+        secret_sharing::{replicated::semi_honest::AdditiveShare, IntoShares},
+        test_executor::run,
+        test_fixture::{Reconstruct, Runner, TestWorld},
+    };
+
+    ///defining test input struct
+    #[derive(Copy, Clone)]
+    struct ShuffledTestInput {
+        match_key: Fp25519,
+    }
+
+    ///defining test output struct
+    #[derive(Debug, PartialEq)]
+    struct TestOutput {
+        match_key_pseudonym: u64,
+    }
+
+    fn test_input(mk: u64) -> ShuffledTestInput {
+        ShuffledTestInput {
+            match_key: Fp25519::from(mk),
+        }
+    }
+
+    impl IntoShares<AdditiveShare<Fp25519>> for ShuffledTestInput {
+        fn share_with<R: Rng>(self, rng: &mut R) -> [AdditiveShare<Fp25519>; 3] {
+            self.match_key.share_with(rng)
+        }
+    }
+
+    impl Reconstruct<TestOutput> for [&u64; 3] {
+        fn reconstruct(&self) -> TestOutput {
+            TestOutput {
+                match_key_pseudonym: if *self[0] == *self[1] && *self[0] == *self[2] {
+                    *self[0]
+                } else {
+                    0u64
+                },
+            }
+        }
+    }
+
+    ///testing correctness of DY PRF evaluation
+    /// by checking MPC generated pseudonym with pseudonym generated in the clear
+    #[test]
+    fn semi_honest() {
+        run(|| async move {
+            let world = TestWorld::default();
+
+            //first two need to be identical for test to succeed
+            let records: Vec<ShuffledTestInput> = vec![
+                test_input(3),
+                test_input(3),
+                test_input(23_443_524_523),
+                test_input(56),
+                test_input(895_764_542),
+                test_input(456_764_576),
+                test_input(56),
+                test_input(3),
+                test_input(56),
+                test_input(23_443_524_523),
+            ];
+
+            //PRF Key Gen
+            let u = 3_216_412_445u64;
+            let k: Fp25519 = Fp25519::from(u);
+
+            let expected: Vec<TestOutput> = records
+                .iter()
+                .map(|&x| TestOutput {
+                    match_key_pseudonym: (RP25519::from((x.match_key + k).invert())).into(),
+                })
+                .collect();
+
+            let result: Vec<_> = world
+                .semi_honest(
+                    (records.into_iter(), k),
+                    |ctx, (input_match_keys, prf_key)| async move {
+                        compute_match_key_pseudonym::<_>(ctx, prf_key, input_match_keys)
+                            .await
+                            .unwrap()
+                    },
+                )
+                .await
+                .reconstruct();
+            assert_eq!(result, expected);
+            assert_eq!(result[0], result[1]);
+        });
+    }
+}
diff --git a/src/protocol/prf_sharding/bucket.rs b/src/protocol/ipa_prf/prf_sharding/bucket.rs
similarity index 98%
rename from src/protocol/prf_sharding/bucket.rs
rename to src/protocol/ipa_prf/prf_sharding/bucket.rs
index d2ad77a11..a1e62d1a2 100644
--- a/src/protocol/prf_sharding/bucket.rs
+++ b/src/protocol/ipa_prf/prf_sharding/bucket.rs
@@ -5,7 +5,8 @@ use crate::{
     error::Error,
     ff::{GaloisField, PrimeField, Serializable},
     protocol::{
-        basics::SecureMul, context::UpgradedContext, prf_sharding::BinaryTreeDepthStep, RecordId,
+        basics::SecureMul, context::UpgradedContext, ipa_prf::prf_sharding::BinaryTreeDepthStep,
+        RecordId,
     },
     secret_sharing::{
         replicated::malicious::ExtendableField, BitDecomposed, Linear as LinearSecretSharing,
@@ -124,7 +125,7 @@ pub mod tests {
         ff::{Field, Fp32BitPrime, Gf8Bit, Gf9Bit},
         protocol::{
             context::{Context, UpgradableContext, Validator},
-            prf_sharding::bucket::move_single_value_to_bucket,
+            ipa_prf::prf_sharding::bucket::move_single_value_to_bucket,
             RecordId,
         },
         rand::Rng,
diff --git a/src/protocol/prf_sharding/feature_label_dot_product.rs b/src/protocol/ipa_prf/prf_sharding/feature_label_dot_product.rs
similarity index 99%
rename from src/protocol/prf_sharding/feature_label_dot_product.rs
rename to src/protocol/ipa_prf/prf_sharding/feature_label_dot_product.rs
index f87f788d8..bc492b62c 100644
--- a/src/protocol/prf_sharding/feature_label_dot_product.rs
+++ b/src/protocol/ipa_prf/prf_sharding/feature_label_dot_product.rs
@@ -371,7 +371,7 @@ where
 pub mod tests {
     use crate::{
         ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf32Bit},
-        protocol::prf_sharding::feature_label_dot_product::{
+        protocol::ipa_prf::prf_sharding::feature_label_dot_product::{
             compute_feature_label_dot_product, PrfShardedIpaInputRow,
         },
         rand::Rng,
diff --git a/src/protocol/prf_sharding/mod.rs b/src/protocol/ipa_prf/prf_sharding/mod.rs
similarity index 99%
rename from src/protocol/prf_sharding/mod.rs
rename to src/protocol/ipa_prf/prf_sharding/mod.rs
index 9763ab0f6..db62c95e0 100644
--- a/src/protocol/prf_sharding/mod.rs
+++ b/src/protocol/ipa_prf/prf_sharding/mod.rs
@@ -12,16 +12,15 @@ use futures_util::{
 };
 use ipa_macros::Step;
 
-use super::{boolean::saturating_sum::SaturatingSum, modulus_conversion::ToBitConversionTriples};
 use crate::{
     error::Error,
     ff::{Field, GaloisField, Gf2, PrimeField, Serializable},
     helpers::Role,
     protocol::{
         basics::{if_else, SecureMul, ShareKnownValue},
-        boolean::{comparison::bitwise_less_than_constant, or::or},
+        boolean::{comparison::bitwise_less_than_constant, or::or, saturating_sum::SaturatingSum},
         context::{Context, UpgradableContext, UpgradedContext, Validator},
-        modulus_conversion::{convert_bits, BitConversionTriple},
+        modulus_conversion::{convert_bits, BitConversionTriple, ToBitConversionTriples},
         step::BitOpStep,
         RecordId,
     },
@@ -831,7 +830,7 @@ pub mod tests {
     use super::{CappedAttributionOutputs, PrfShardedIpaInputRow};
     use crate::{
         ff::{Field, Fp32BitPrime, GaloisField, Gf2, Gf20Bit, Gf3Bit, Gf5Bit},
-        protocol::prf_sharding::attribution_and_capping_and_aggregation,
+        protocol::ipa_prf::prf_sharding::attribution_and_capping_and_aggregation,
         rand::Rng,
         secret_sharing::{
             replicated::semi_honest::AdditiveShare as Replicated, BitDecomposed, IntoShares,
diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs
index 6ee9ae59d..dc8f89fa1 100644
--- a/src/protocol/mod.rs
+++ b/src/protocol/mod.rs
@@ -5,8 +5,8 @@ pub mod boolean;
 pub mod context;
 pub mod dp;
 pub mod ipa;
+pub mod ipa_prf;
 pub mod modulus_conversion;
-pub mod prf_sharding;
 pub mod prss;
 pub mod sort;
 pub mod step;
diff --git a/src/query/runner/oprf_ipa.rs b/src/query/runner/oprf_ipa.rs
index c4e0f25f2..f3f7136ea 100644
--- a/src/query/runner/oprf_ipa.rs
+++ b/src/query/runner/oprf_ipa.rs
@@ -12,7 +12,7 @@ use crate::{
     protocol::{
         basics::ShareKnownValue,
         context::{UpgradableContext, UpgradedContext},
-        prf_sharding::{
+        ipa_prf::prf_sharding::{
             attribution_and_capping_and_aggregation, compute_histogram_of_users_with_row_count,
             PrfShardedIpaInputRow,
         },
diff --git a/src/report.rs b/src/report.rs
index f4a2bd4d6..f0f827746 100644
--- a/src/report.rs
+++ b/src/report.rs
@@ -17,7 +17,7 @@ use crate::{
         open_in_place, seal_in_place, CryptError, FieldShareCrypt, Info, KeyPair, KeyRegistry,
         PublicKeyRegistry,
     },
-    protocol::prf_sharding::GroupingKey,
+    protocol::ipa_prf::prf_sharding::GroupingKey,
     secret_sharing::replicated::semi_honest::AdditiveShare as Replicated,
 };
 
diff --git a/src/secret_sharing/mod.rs b/src/secret_sharing/mod.rs
index f366c870c..441fe1f21 100644
--- a/src/secret_sharing/mod.rs
+++ b/src/secret_sharing/mod.rs
@@ -23,22 +23,25 @@ pub use scheme::{Bitwise, Linear, LinearRefOps, SecretSharing};
 
 use crate::ff::{AddSub, AddSubAssign, Serializable};
 
+/// Operations supported for weak shared values.
+pub trait Additive<Rhs = Self, Output = Self>:
+    AddSub<Rhs, Output> + AddSubAssign<Rhs> + Neg<Output = Output>
+{
+}
+
+impl<T, Rhs, Output> Additive<Rhs, Output> for T where
+    T: AddSub<Rhs, Output> + AddSubAssign<Rhs> + Neg<Output = Output>
+{
+}
+
 /// Operations supported for shared values.
 pub trait Arithmetic<Rhs = Self, Output = Self>:
-    AddSub<Rhs, Output>
-    + AddSubAssign<Rhs>
-    + Mul<Rhs, Output = Output>
-    + MulAssign<Rhs>
-    + Neg<Output = Output>
+    Additive<Rhs, Output> + Mul<Rhs, Output = Output> + MulAssign<Rhs>
 {
 }
 
 impl<T, Rhs, Output> Arithmetic<Rhs, Output> for T where
-    T: AddSub<Rhs, Output>
-        + AddSubAssign<Rhs>
-        + Mul<Rhs, Output = Output>
-        + MulAssign<Rhs>
-        + Neg<Output = Output>
+    T: Additive<Rhs, Output> + Mul<Rhs, Output = Output> + MulAssign<Rhs>
 {
 }
 
@@ -48,6 +51,18 @@ pub trait Block: Sized + Copy + Debug {
     type Size: ArrayLength;
 }
 
+///allows basic secret sharing operations
+pub trait WeakSharedValue:
+    Clone + Copy + PartialEq + Debug + Send + Sync + Sized + Additive + Serializable + 'static
+{
+    type Storage: Block;
+
+    const BITS: u32;
+
+    const ZERO: Self;
+}
+
+///allows advanced secret sharing operations, requires multiplication
 pub trait SharedValue:
     Clone + Copy + PartialEq + Debug + Send + Sync + Sized + Arithmetic + Serializable + 'static
 {
@@ -58,10 +73,22 @@ pub trait SharedValue:
     const ZERO: Self;
 }
 
+///any `SharedValue` is also a `WeakSharedValue`
+impl<T> WeakSharedValue for T
+where
+    T: SharedValue,
+{
+    type Storage = T::Storage;
+
+    const BITS: u32 = T::BITS;
+
+    const ZERO: Self = T::ZERO;
+}
+
 #[cfg(any(test, feature = "test-fixture", feature = "cli"))]
 impl<V> IntoShares<AdditiveShare<V>> for V
 where
-    V: SharedValue,
+    V: WeakSharedValue,
     Standard: Distribution<V>,
 {
     fn share_with<R: Rng>(self, rng: &mut R) -> [AdditiveShare<V>; 3] {
diff --git a/src/secret_sharing/replicated/mod.rs b/src/secret_sharing/replicated/mod.rs
index dcf51494e..80c8167b0 100644
--- a/src/secret_sharing/replicated/mod.rs
+++ b/src/secret_sharing/replicated/mod.rs
@@ -1,9 +1,9 @@
 pub mod malicious;
 pub mod semi_honest;
 
-use super::{SecretSharing, SharedValue};
+use super::{SecretSharing, SharedValue, WeakSharedValue};
 
-pub trait ReplicatedSecretSharing<V: SharedValue>: SecretSharing<V> {
+pub trait ReplicatedSecretSharing<V: WeakSharedValue>: SecretSharing<V> {
     fn new(a: V, b: V) -> Self;
     fn left(&self) -> V;
     fn right(&self) -> V;
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index 10b8b2b39..0ae455ea9 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -10,32 +10,32 @@ use crate::{
     ff::Serializable,
     secret_sharing::{
         replicated::ReplicatedSecretSharing, Linear as LinearSecretSharing, SecretSharing,
-        SharedValue,
+        SharedValue, WeakSharedValue,
     },
 };
 
 #[derive(Clone, PartialEq, Eq)]
-pub struct AdditiveShare<V: SharedValue>(V, V);
+pub struct AdditiveShare<V: WeakSharedValue>(V, V);
 
-impl<V: SharedValue> SecretSharing<V> for AdditiveShare<V> {
+impl<V: WeakSharedValue> SecretSharing<V> for AdditiveShare<V> {
     const ZERO: Self = AdditiveShare::ZERO;
 }
 
 impl<V: SharedValue> LinearSecretSharing<V> for AdditiveShare<V> {}
 
-impl<V: SharedValue + Debug> Debug for AdditiveShare<V> {
+impl<V: WeakSharedValue + Debug> Debug for AdditiveShare<V> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "({:?}, {:?})", self.0, self.1)
     }
 }
 
-impl<V: SharedValue> Default for AdditiveShare<V> {
+impl<V: WeakSharedValue> Default for AdditiveShare<V> {
     fn default() -> Self {
         AdditiveShare::new(V::ZERO, V::ZERO)
     }
 }
 
-impl<V: SharedValue> AdditiveShare<V> {
+impl<V: WeakSharedValue> AdditiveShare<V> {
     /// Replicated secret share where both left and right values are `F::ZERO`
     pub const ZERO: Self = Self(V::ZERO, V::ZERO);
 
@@ -44,7 +44,7 @@ impl<V: SharedValue> AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> ReplicatedSecretSharing<V> for AdditiveShare<V> {
+impl<V: WeakSharedValue> ReplicatedSecretSharing<V> for AdditiveShare<V> {
     fn new(a: V, b: V) -> Self {
         Self(a, b)
     }
@@ -58,7 +58,7 @@ impl<V: SharedValue> ReplicatedSecretSharing<V> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> AdditiveShare<V>
+impl<V: WeakSharedValue> AdditiveShare<V>
 where
     Self: Serializable,
 {
@@ -73,7 +73,7 @@ where
     }
 }
 
-impl<'a, 'b, V: SharedValue> Add<&'b AdditiveShare<V>> for &'a AdditiveShare<V> {
+impl<'a, 'b, V: WeakSharedValue> Add<&'b AdditiveShare<V>> for &'a AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
     fn add(self, rhs: &'b AdditiveShare<V>) -> Self::Output {
@@ -81,7 +81,7 @@ impl<'a, 'b, V: SharedValue> Add<&'b AdditiveShare<V>> for &'a AdditiveShare<V>
     }
 }
 
-impl<V: SharedValue> Add<Self> for AdditiveShare<V> {
+impl<V: WeakSharedValue> Add<Self> for AdditiveShare<V> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
@@ -89,7 +89,7 @@ impl<V: SharedValue> Add<Self> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Add<AdditiveShare<V>> for &AdditiveShare<V> {
+impl<V: WeakSharedValue> Add<AdditiveShare<V>> for &AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
     fn add(self, rhs: AdditiveShare<V>) -> Self::Output {
@@ -97,7 +97,7 @@ impl<V: SharedValue> Add<AdditiveShare<V>> for &AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Add<&AdditiveShare<V>> for AdditiveShare<V> {
+impl<V: WeakSharedValue> Add<&AdditiveShare<V>> for AdditiveShare<V> {
     type Output = Self;
 
     fn add(self, rhs: &Self) -> Self::Output {
@@ -105,20 +105,20 @@ impl<V: SharedValue> Add<&AdditiveShare<V>> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> AddAssign<&Self> for AdditiveShare<V> {
+impl<V: WeakSharedValue> AddAssign<&Self> for AdditiveShare<V> {
     fn add_assign(&mut self, rhs: &Self) {
         self.0 += rhs.0;
         self.1 += rhs.1;
     }
 }
 
-impl<V: SharedValue> AddAssign<Self> for AdditiveShare<V> {
+impl<V: WeakSharedValue> AddAssign<Self> for AdditiveShare<V> {
     fn add_assign(&mut self, rhs: Self) {
         AddAssign::add_assign(self, &rhs);
     }
 }
 
-impl<V: SharedValue> Neg for &AdditiveShare<V> {
+impl<V: WeakSharedValue> Neg for &AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
     fn neg(self) -> Self::Output {
@@ -126,7 +126,7 @@ impl<V: SharedValue> Neg for &AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Neg for AdditiveShare<V> {
+impl<V: WeakSharedValue> Neg for AdditiveShare<V> {
     type Output = Self;
 
     fn neg(self) -> Self::Output {
@@ -134,7 +134,7 @@ impl<V: SharedValue> Neg for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Sub<Self> for &AdditiveShare<V> {
+impl<V: WeakSharedValue> Sub<Self> for &AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
     fn sub(self, rhs: Self) -> Self::Output {
@@ -142,7 +142,7 @@ impl<V: SharedValue> Sub<Self> for &AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Sub<Self> for AdditiveShare<V> {
+impl<V: WeakSharedValue> Sub<Self> for AdditiveShare<V> {
     type Output = Self;
 
     fn sub(self, rhs: Self) -> Self::Output {
@@ -150,7 +150,7 @@ impl<V: SharedValue> Sub<Self> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Sub<&Self> for AdditiveShare<V> {
+impl<V: WeakSharedValue> Sub<&Self> for AdditiveShare<V> {
     type Output = Self;
 
     fn sub(self, rhs: &Self) -> Self::Output {
@@ -158,7 +158,7 @@ impl<V: SharedValue> Sub<&Self> for AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> Sub<AdditiveShare<V>> for &AdditiveShare<V> {
+impl<V: WeakSharedValue> Sub<AdditiveShare<V>> for &AdditiveShare<V> {
     type Output = AdditiveShare<V>;
 
     fn sub(self, rhs: AdditiveShare<V>) -> Self::Output {
@@ -166,14 +166,14 @@ impl<V: SharedValue> Sub<AdditiveShare<V>> for &AdditiveShare<V> {
     }
 }
 
-impl<V: SharedValue> SubAssign<&Self> for AdditiveShare<V> {
+impl<V: WeakSharedValue> SubAssign<&Self> for AdditiveShare<V> {
     fn sub_assign(&mut self, rhs: &Self) {
         self.0 -= rhs.0;
         self.1 -= rhs.1;
     }
 }
 
-impl<V: SharedValue> SubAssign<Self> for AdditiveShare<V> {
+impl<V: WeakSharedValue> SubAssign<Self> for AdditiveShare<V> {
     fn sub_assign(&mut self, rhs: Self) {
         SubAssign::sub_assign(self, &rhs);
     }
diff --git a/src/secret_sharing/scheme.rs b/src/secret_sharing/scheme.rs
index cd6556211..0d2131eeb 100644
--- a/src/secret_sharing/scheme.rs
+++ b/src/secret_sharing/scheme.rs
@@ -3,11 +3,11 @@ use std::{
     ops::{Mul, Neg},
 };
 
-use super::SharedValue;
+use super::{SharedValue, WeakSharedValue};
 use crate::ff::{AddSub, AddSubAssign, GaloisField};
 
 /// Secret sharing scheme i.e. Replicated secret sharing
-pub trait SecretSharing<V: SharedValue>: Clone + Debug + Sized + Send + Sync {
+pub trait SecretSharing<V: WeakSharedValue>: Clone + Debug + Sized + Send + Sync {
     const ZERO: Self;
 }
 
diff --git a/src/test_fixture/ipa.rs b/src/test_fixture/ipa.rs
index 0e2b0ecb1..5529079ee 100644
--- a/src/test_fixture/ipa.rs
+++ b/src/test_fixture/ipa.rs
@@ -1,6 +1,6 @@
 use std::{collections::HashMap, num::NonZeroU32, ops::Deref};
 
-use crate::protocol::prf_sharding::GroupingKey;
+use crate::protocol::ipa_prf::prf_sharding::GroupingKey;
 #[cfg(feature = "in-memory-infra")]
 use crate::{
     ff::{PrimeField, Serializable},
@@ -250,7 +250,7 @@ pub async fn test_oprf_ipa<F>(
         ff::{Field, Gf2},
         protocol::{
             basics::ShareKnownValue,
-            prf_sharding::{
+            ipa_prf::prf_sharding::{
                 attribution_and_capping_and_aggregation, compute_histogram_of_users_with_row_count,
                 PrfShardedIpaInputRow,
             },

From 4d4dbb154e5e0ba6336716295ab694bf8ab70f3b Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Mon, 6 Nov 2023 12:06:09 -0800
Subject: [PATCH 097/105] Temporarily disable sanitizers in GH workflow

See https://github.com/private-attribution/ipa/issues/837 for details
---
 .github/workflows/check.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index a7eda1177..15c5d5b57 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -142,6 +142,8 @@ jobs:
 
   # sanitizers currently require nightly https://github.com/rust-lang/rust/issues/39699
   sanitize:
+    # disabled due to https://github.com/private-attribution/ipa/issues/837
+    if: false
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false

From 079b476678c9e54fb8f2c4dc6f4fc0e32a2e3e29 Mon Sep 17 00:00:00 2001
From: Alex Koshelev <akoshelev@users.noreply.github.com>
Date: Mon, 6 Nov 2023 15:42:25 -0800
Subject: [PATCH 098/105] Instrumenting infrastructure with stall detection
 (#832)

* Infra stall detection

Co-authored-by: Andy Leiserson <aleiserson@mozilla.com>
---
 Cargo.toml                                |   9 +-
 src/helpers/buffers/mod.rs                |  34 --
 src/helpers/buffers/ordering_sender.rs    |  23 ++
 src/helpers/buffers/unordered_receiver.rs |  71 ++++-
 src/helpers/gateway/mod.rs                |  79 +++--
 src/helpers/gateway/receive.rs            |  33 +-
 src/helpers/gateway/send.rs               |  12 +-
 src/helpers/gateway/stall_detection.rs    | 372 ++++++++++++++++++++++
 src/helpers/gateway/transport.rs          |  12 +-
 src/helpers/mod.rs                        |  34 +-
 src/helpers/prss_protocol.rs              |   6 +-
 src/lib.rs                                |  20 +-
 src/protocol/step/compact.rs              |   2 +-
 src/protocol/step/descriptive.rs          |   2 +-
 14 files changed, 603 insertions(+), 106 deletions(-)
 create mode 100644 src/helpers/gateway/stall_detection.rs

diff --git a/Cargo.toml b/Cargo.toml
index f65c44f08..9962d04ec 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,9 @@ default = [
     "tracing/release_max_level_info",
     "descriptive-gate",
     "aggregate-circuit",
-    "ipa-prf"
+    "stall-detection",
+    "aggregate-circuit",
+    "ipa-prf",
 ]
 cli = ["comfy-table", "clap"]
 enable-serde = ["serde", "serde_json"]
@@ -22,6 +24,10 @@ disable-metrics = []
 # TODO Consider moving out benches as well
 web-app = ["axum", "axum-server", "base64", "clap", "comfy-table", "enable-serde", "hyper", "hyper-rustls", "rcgen", "rustls", "rustls-pemfile", "time", "tokio-rustls", "toml", "tower", "tower-http"]
 test-fixture = ["enable-serde", "weak-field"]
+# Include observability instruments that detect lack of progress inside MPC. If there is a bug that leads to helper
+# miscommunication, this feature helps to detect it. Turning it on has some cost.
+# If "shuttle" feature is enabled, turning this on has no effect.
+stall-detection = []
 shuttle = ["shuttle-crate", "test-fixture"]
 debug-trace = ["tracing/max_level_trace", "tracing/release_max_level_debug"]
 # TODO: we may want to use in-memory-bench and real-world-bench some time after
@@ -59,6 +65,7 @@ config = "0.13.2"
 criterion = { version = "0.5.1", optional = true, default-features = false, features = ["async_tokio", "plotters", "html_reports"] }
 curve25519-dalek = "4.1.1"
 dashmap = "5.4"
+delegate = "0.10.0"
 dhat = "0.3.2"
 embed-doc-image = "0.1.4"
 futures = "0.3.28"
diff --git a/src/helpers/buffers/mod.rs b/src/helpers/buffers/mod.rs
index 83a92c24e..943c884dd 100644
--- a/src/helpers/buffers/mod.rs
+++ b/src/helpers/buffers/mod.rs
@@ -5,37 +5,3 @@ mod unordered_receiver;
 pub use ordering_mpsc::{ordering_mpsc, OrderingMpscReceiver, OrderingMpscSender};
 pub use ordering_sender::{OrderedStream, OrderingSender};
 pub use unordered_receiver::UnorderedReceiver;
-
-#[cfg(debug_assertions)]
-#[allow(unused)] // todo(alex): make test world print the state again
-mod waiting {
-    use std::collections::HashMap;
-
-    use crate::helpers::ChannelId;
-
-    pub(in crate::helpers) struct WaitingTasks<'a> {
-        tasks: HashMap<&'a ChannelId, Vec<u32>>,
-    }
-
-    impl<'a> WaitingTasks<'a> {
-        pub fn new(tasks: HashMap<&'a ChannelId, Vec<u32>>) -> Self {
-            Self { tasks }
-        }
-
-        pub fn is_empty(&self) -> bool {
-            self.tasks.is_empty()
-        }
-    }
-
-    impl std::fmt::Debug for WaitingTasks<'_> {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "[")?;
-            for (channel, records) in &self.tasks {
-                write!(f, "\n    {channel:?}: {records:?}")?;
-            }
-            write!(f, "\n]")?;
-
-            Ok(())
-        }
-    }
-}
diff --git a/src/helpers/buffers/ordering_sender.rs b/src/helpers/buffers/ordering_sender.rs
index ea1459d62..5ecc21c7f 100644
--- a/src/helpers/buffers/ordering_sender.rs
+++ b/src/helpers/buffers/ordering_sender.rs
@@ -188,6 +188,11 @@ impl WaitingShard {
             self.wakers.pop_front().unwrap().w.wake();
         }
     }
+
+    #[cfg(feature = "stall-detection")]
+    pub fn waiting(&self) -> impl Iterator<Item = usize> + '_ {
+        self.wakers.iter().map(|waker| waker.i)
+    }
 }
 
 /// A collection of wakers that are indexed by the send index (`i`).
@@ -224,6 +229,19 @@ impl Waiting {
     fn wake(&self, i: usize) {
         self.shard(i).wake(i);
     }
+
+    /// Returns all records currently waiting to be sent in sorted order.
+    #[cfg(feature = "stall-detection")]
+    fn waiting(&self) -> Vec<usize> {
+        let mut records = Vec::new();
+        self.shards
+            .iter()
+            .for_each(|shard| records.extend(shard.lock().unwrap().waiting()));
+
+        records.sort_unstable();
+
+        records
+    }
 }
 
 /// An `OrderingSender` accepts messages for sending in any order, but
@@ -375,6 +393,11 @@ impl OrderingSender {
     ) -> OrderedStream<crate::sync::Arc<Self>> {
         OrderedStream { sender: self }
     }
+
+    #[cfg(feature = "stall-detection")]
+    pub fn waiting(&self) -> Vec<usize> {
+        self.waiting.waiting()
+    }
 }
 
 /// A future for writing item `i` into an `OrderingSender`.
diff --git a/src/helpers/buffers/unordered_receiver.rs b/src/helpers/buffers/unordered_receiver.rs
index d578e6456..88de6996e 100644
--- a/src/helpers/buffers/unordered_receiver.rs
+++ b/src/helpers/buffers/unordered_receiver.rs
@@ -116,6 +116,8 @@ where
     stream: Pin<Box<S>>,
     /// The absolute index of the next value that will be received.
     next: usize,
+    /// The maximum value that has ever been requested to receive.
+    max_polled_idx: usize,
     /// The underlying stream can provide chunks of data larger than a single
     /// message.  Save any spare data here.
     spare: Spare,
@@ -143,6 +145,12 @@ where
     /// Note: in protocols we try to send before receiving, so we can rely on
     /// that easing load on this mechanism.  There might also need to be some
     /// end-to-end back pressure for tasks that do not involve sending at all.
+    ///
+    /// If stall detection is enabled, the index of that waker is stored alongside with it, in order
+    /// to correctly identify the `i` awaiting completion
+    #[cfg(feature = "stall-detection")]
+    overflow_wakers: Vec<(Waker, usize)>,
+    #[cfg(not(feature = "stall-detection"))]
     overflow_wakers: Vec<Waker>,
     _marker: PhantomData<C>,
 }
@@ -172,7 +180,11 @@ where
         );
         // We don't save a waker at `self.next`, so `>` and not `>=`.
         if i > self.next + self.wakers.len() {
-            self.overflow_wakers.push(waker);
+            #[cfg(feature = "stall-detection")]
+            let overflow = (waker, i);
+            #[cfg(not(feature = "stall-detection"))]
+            let overflow = waker;
+            self.overflow_wakers.push(overflow);
         } else {
             let index = i % self.wakers.len();
             if let Some(old) = self.wakers[index].as_ref() {
@@ -195,6 +207,11 @@ where
         }
         if self.next % (self.wakers.len() / 2) == 0 {
             // Wake all the overflowed wakers.  See comments on `overflow_wakers`.
+            #[cfg(feature = "stall-detection")]
+            for (w, _) in take(&mut self.overflow_wakers) {
+                w.wake();
+            }
+            #[cfg(not(feature = "stall-detection"))]
             for w in take(&mut self.overflow_wakers) {
                 w.wake();
             }
@@ -204,6 +221,7 @@ where
     /// Poll for the next record.  This should only be invoked when
     /// the future for the next message is polled.
     fn poll_next<M: Message>(&mut self, cx: &mut Context<'_>) -> Poll<Result<M, Error>> {
+        self.max_polled_idx = std::cmp::max(self.max_polled_idx, self.next);
         if let Some(m) = self.spare.read() {
             self.wake_next();
             return Poll::Ready(Ok(m));
@@ -228,6 +246,46 @@ where
             }
         }
     }
+
+    #[cfg(feature = "stall-detection")]
+    fn waiting(&self) -> impl Iterator<Item = usize> + '_ {
+        /// There is no waker for self.next and it could be advanced past the end of the stream.
+        /// This helps to conditionally add self.next to the waiting list.
+        struct MaybeNext {
+            currently_at: usize,
+            next: usize,
+        }
+        impl Iterator for MaybeNext {
+            type Item = usize;
+
+            fn next(&mut self) -> Option<Self::Item> {
+                if self.currently_at == self.next {
+                    self.currently_at += 1;
+                    Some(self.next)
+                } else {
+                    None
+                }
+            }
+        }
+
+        let start = self.next % self.wakers.len();
+        self.wakers
+            .iter()
+            .enumerate()
+            .filter_map(|(i, waker)| waker.as_ref().map(|_| i))
+            .map(move |i| {
+                if i < start {
+                    self.next + (self.wakers.len() - start + i)
+                } else {
+                    self.next + (i - start)
+                }
+            })
+            .chain(self.overflow_wakers.iter().map(|v| v.1))
+            .chain(MaybeNext {
+                currently_at: self.max_polled_idx,
+                next: self.next,
+            })
+    }
 }
 
 /// Take an ordered stream of bytes and make messages from that stream
@@ -262,6 +320,7 @@ where
             inner: Arc::new(Mutex::new(OperatingState {
                 stream,
                 next: 0,
+                max_polled_idx: 0,
                 spare: Spare::default(),
                 wakers,
                 overflow_wakers: Vec::new(),
@@ -284,6 +343,16 @@ where
             _marker: PhantomData,
         }
     }
+
+    #[cfg(feature = "stall-detection")]
+    pub fn waiting(&self) -> Vec<usize> {
+        let state = self.inner.lock().unwrap();
+        let mut r = state.waiting().collect::<Vec<_>>();
+
+        r.sort_unstable();
+
+        r
+    }
 }
 
 impl<S, C> Clone for UnorderedReceiver<S, C>
diff --git a/src/helpers/gateway/mod.rs b/src/helpers/gateway/mod.rs
index c2a37916c..4fd839ca5 100644
--- a/src/helpers/gateway/mod.rs
+++ b/src/helpers/gateway/mod.rs
@@ -1,19 +1,22 @@
 mod receive;
 mod send;
+#[cfg(feature = "stall-detection")]
+pub(super) mod stall_detection;
 mod transport;
 
-use std::{fmt::Debug, num::NonZeroUsize};
+use std::num::NonZeroUsize;
 
-pub use send::SendingEnd;
-#[cfg(all(feature = "shuttle", test))]
+pub(super) use receive::ReceivingEnd;
+pub(super) use send::SendingEnd;
+#[cfg(all(test, feature = "shuttle"))]
 use shuttle::future as tokio;
+#[cfg(feature = "stall-detection")]
+pub(super) use stall_detection::InstrumentedGateway;
 
 use crate::{
     helpers::{
         gateway::{
-            receive::{GatewayReceivers, ReceivingEnd as ReceivingEndBase},
-            send::GatewaySenders,
-            transport::RoleResolvingTransport,
+            receive::GatewayReceivers, send::GatewaySenders, transport::RoleResolvingTransport,
         },
         ChannelId, Message, Role, RoleAssignment, TotalRecords, Transport,
     },
@@ -31,18 +34,21 @@ pub type TransportImpl = super::transport::InMemoryTransport;
 pub type TransportImpl = crate::sync::Arc<crate::net::HttpTransport>;
 
 pub type TransportError = <TransportImpl as Transport>::Error;
-pub type ReceivingEnd<M> = ReceivingEndBase<TransportImpl, M>;
 
-/// Gateway into IPA Infrastructure systems. This object allows sending and receiving messages.
-/// As it is generic over network/transport layer implementation, type alias [`Gateway`] should be
-/// used to avoid carrying `T` over.
-///
-/// [`Gateway`]: crate::helpers::Gateway
-pub struct Gateway<T: Transport = TransportImpl> {
+/// Gateway into IPA Network infrastructure. It allows helpers send and receive messages.
+pub struct Gateway {
     config: GatewayConfig,
-    transport: RoleResolvingTransport<T>,
+    transport: RoleResolvingTransport,
+    #[cfg(feature = "stall-detection")]
+    inner: crate::sync::Arc<State>,
+    #[cfg(not(feature = "stall-detection"))]
+    inner: State,
+}
+
+#[derive(Default)]
+pub struct State {
     senders: GatewaySenders,
-    receivers: GatewayReceivers<T>,
+    receivers: GatewayReceivers,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -50,16 +56,23 @@ pub struct GatewayConfig {
     /// The number of items that can be active at the one time.
     /// This is used to determine the size of sending and receiving buffers.
     active: NonZeroUsize,
+
+    /// Time to wait before checking gateway progress. If no progress has been made between
+    /// checks, the gateway is considered to be stalled and will create a report with outstanding
+    /// send/receive requests
+    #[cfg(feature = "stall-detection")]
+    pub progress_check_interval: std::time::Duration,
 }
 
-impl<T: Transport> Gateway<T> {
+impl Gateway {
     #[must_use]
     pub fn new(
         query_id: QueryId,
         config: GatewayConfig,
         roles: RoleAssignment,
-        transport: T,
+        transport: TransportImpl,
     ) -> Self {
+        #[allow(clippy::useless_conversion)] // not useless in stall-detection build
         Self {
             config,
             transport: RoleResolvingTransport {
@@ -68,8 +81,7 @@ impl<T: Transport> Gateway<T> {
                 inner: transport,
                 config,
             },
-            senders: GatewaySenders::default(),
-            receivers: GatewayReceivers::default(),
+            inner: State::default().into(),
         }
     }
 
@@ -91,10 +103,12 @@ impl<T: Transport> Gateway<T> {
         &self,
         channel_id: &ChannelId,
         total_records: TotalRecords,
-    ) -> SendingEnd<M> {
-        let (tx, maybe_stream) =
-            self.senders
-                .get_or_create::<M>(channel_id, self.config.active_work(), total_records);
+    ) -> send::SendingEnd<M> {
+        let (tx, maybe_stream) = self.inner.senders.get_or_create::<M>(
+            channel_id,
+            self.config.active_work(),
+            total_records,
+        );
         if let Some(stream) = maybe_stream {
             tokio::spawn({
                 let channel_id = channel_id.clone();
@@ -109,14 +123,15 @@ impl<T: Transport> Gateway<T> {
             });
         }
 
-        SendingEnd::new(tx, self.role(), channel_id)
+        send::SendingEnd::new(tx, self.role(), channel_id)
     }
 
     #[must_use]
-    pub fn get_receiver<M: Message>(&self, channel_id: &ChannelId) -> ReceivingEndBase<T, M> {
-        ReceivingEndBase::new(
+    pub fn get_receiver<M: Message>(&self, channel_id: &ChannelId) -> receive::ReceivingEnd<M> {
+        receive::ReceivingEnd::new(
             channel_id.clone(),
-            self.receivers
+            self.inner
+                .receivers
                 .get_or_create(channel_id, || self.transport.receive(channel_id)),
         )
     }
@@ -135,8 +150,18 @@ impl GatewayConfig {
     /// If `active` is 0.
     #[must_use]
     pub fn new(active: usize) -> Self {
+        // In-memory tests are fast, so progress check intervals can be lower.
+        // Real world scenarios currently over-report stalls because of inefficiencies inside
+        // infrastructure and actual networking issues. This checks is only valuable to report
+        // bugs, so keeping it large enough to avoid false positives.
         Self {
             active: NonZeroUsize::new(active).unwrap(),
+            #[cfg(feature = "stall-detection")]
+            progress_check_interval: std::time::Duration::from_secs(if cfg!(test) {
+                5
+            } else {
+                30
+            }),
         }
     }
 
diff --git a/src/helpers/gateway/receive.rs b/src/helpers/gateway/receive.rs
index b039c8653..0b2686ff1 100644
--- a/src/helpers/gateway/receive.rs
+++ b/src/helpers/gateway/receive.rs
@@ -4,29 +4,30 @@ use dashmap::{mapref::entry::Entry, DashMap};
 use futures::Stream;
 
 use crate::{
-    helpers::{buffers::UnorderedReceiver, ChannelId, Error, Message, Transport},
+    helpers::{buffers::UnorderedReceiver, ChannelId, Error, Message, Transport, TransportImpl},
     protocol::RecordId,
 };
 
 /// Receiving end end of the gateway channel.
-pub struct ReceivingEnd<T: Transport, M: Message> {
+pub struct ReceivingEnd<M: Message> {
     channel_id: ChannelId,
-    unordered_rx: UR<T>,
+    unordered_rx: UR,
     _phantom: PhantomData<M>,
 }
 
 /// Receiving channels, indexed by (role, step).
-pub(super) struct GatewayReceivers<T: Transport> {
-    inner: DashMap<ChannelId, UR<T>>,
+#[derive(Default)]
+pub(super) struct GatewayReceivers {
+    pub(super) inner: DashMap<ChannelId, UR>,
 }
 
-pub(super) type UR<T> = UnorderedReceiver<
-    <T as Transport>::RecordsStream,
-    <<T as Transport>::RecordsStream as Stream>::Item,
+pub(super) type UR = UnorderedReceiver<
+    <TransportImpl as Transport>::RecordsStream,
+    <<TransportImpl as Transport>::RecordsStream as Stream>::Item,
 >;
 
-impl<T: Transport, M: Message> ReceivingEnd<T, M> {
-    pub(super) fn new(channel_id: ChannelId, rx: UR<T>) -> Self {
+impl<M: Message> ReceivingEnd<M> {
+    pub(super) fn new(channel_id: ChannelId, rx: UR) -> Self {
         Self {
             channel_id,
             unordered_rx: rx,
@@ -56,16 +57,8 @@ impl<T: Transport, M: Message> ReceivingEnd<T, M> {
     }
 }
 
-impl<T: Transport> Default for GatewayReceivers<T> {
-    fn default() -> Self {
-        Self {
-            inner: DashMap::default(),
-        }
-    }
-}
-
-impl<T: Transport> GatewayReceivers<T> {
-    pub fn get_or_create<F: FnOnce() -> UR<T>>(&self, channel_id: &ChannelId, ctr: F) -> UR<T> {
+impl GatewayReceivers {
+    pub fn get_or_create<F: FnOnce() -> UR>(&self, channel_id: &ChannelId, ctr: F) -> UR {
         // TODO: raw entry API if it becomes available to avoid cloning the key
         match self.inner.entry(channel_id.clone()) {
             Entry::Occupied(entry) => entry.get().clone(),
diff --git a/src/helpers/gateway/send.rs b/src/helpers/gateway/send.rs
index 0d32de973..fc8a379e6 100644
--- a/src/helpers/gateway/send.rs
+++ b/src/helpers/gateway/send.rs
@@ -30,7 +30,7 @@ pub struct SendingEnd<M: Message> {
 /// Sending channels, indexed by (role, step).
 #[derive(Default)]
 pub(super) struct GatewaySenders {
-    inner: DashMap<ChannelId, Arc<GatewaySender>>,
+    pub(super) inner: DashMap<ChannelId, Arc<GatewaySender>>,
 }
 
 pub(super) struct GatewaySender {
@@ -77,6 +77,16 @@ impl GatewaySender {
 
         Ok(())
     }
+
+    #[cfg(feature = "stall-detection")]
+    pub fn waiting(&self) -> Vec<usize> {
+        self.ordering_tx.waiting()
+    }
+
+    #[cfg(feature = "stall-detection")]
+    pub fn total_records(&self) -> TotalRecords {
+        self.total_records
+    }
 }
 
 impl<M: Message> SendingEnd<M> {
diff --git a/src/helpers/gateway/stall_detection.rs b/src/helpers/gateway/stall_detection.rs
new file mode 100644
index 000000000..236b09700
--- /dev/null
+++ b/src/helpers/gateway/stall_detection.rs
@@ -0,0 +1,372 @@
+use std::{
+    fmt::{Debug, Display, Formatter},
+    ops::{RangeInclusive, Sub},
+};
+
+pub use gateway::InstrumentedGateway;
+
+use crate::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Weak,
+};
+
+/// Trait for structs that can report their current state.
+pub trait ObserveState {
+    type State: Debug;
+    fn get_state(&self) -> Option<Self::State>;
+}
+
+/// This object does not own the sequence number, it must be stored outside and dropped when
+/// observing entity goes out of scope. If that happens, any attempt to increment it through this
+/// instance will result in a panic.
+///
+/// Observing and incrementing sequence numbers do not introduce happens-before relationship.
+pub struct Observed<T> {
+    /// Each time a state change occurs inside the observable object `T`, its sequence number is
+    /// incremented by 1. It is up to the caller to decide what is a state change.
+    ///
+    /// The sequence number is stored as a weak reference, so it can be dropped when the observed
+    /// object is dropped.
+    ///
+    /// External observers watching this object will declare it stalled if it's sequence number
+    /// hasn't been incremented for long enough time. It can happen for two reasons: either there is
+    /// no work to do for this object, or its state is not drained/consumed by the clients. In the
+    /// former case, the bottleneck is somewhere else, otherwise if `T` implements `ObserveState`,
+    /// the current state of `T` is also reported.
+    sn: Weak<AtomicUsize>,
+    inner: T,
+}
+
+impl<T> Observed<T> {
+    fn wrap(sn: Weak<AtomicUsize>, inner: T) -> Self {
+        Self { sn, inner }
+    }
+
+    fn get_sn(&self) -> &Weak<AtomicUsize> {
+        &self.sn
+    }
+
+    /// Advances the sequence number ahead.
+    ///
+    /// ## Panics
+    /// This will panic if the sequence number is dropped.
+    fn advance(&self) {
+        let sn = self.sn.upgrade().unwrap();
+        sn.fetch_add(1, Ordering::Relaxed);
+    }
+
+    fn inner(&self) -> &T {
+        &self.inner
+    }
+}
+
+impl<T: ObserveState> Observed<T> {
+    pub fn get_state(&self) -> Option<T::State> {
+        self.inner().get_state()
+    }
+}
+
+mod gateway {
+    use delegate::delegate;
+
+    use super::*;
+    use crate::{
+        helpers::{
+            gateway::{Gateway, State},
+            ChannelId, GatewayConfig, Message, ReceivingEnd, Role, RoleAssignment, SendingEnd,
+            TotalRecords, TransportImpl,
+        },
+        protocol::QueryId,
+        sync::Arc,
+    };
+
+    pub struct InstrumentedGateway {
+        gateway: Gateway,
+        // Gateway owns the sequence number associated with it. When it goes out of scope, sn is destroyed
+        // and external observers can see that they no longer need to watch it.
+        _sn: Arc<AtomicUsize>,
+    }
+
+    impl Observed<InstrumentedGateway> {
+        delegate! {
+            to self.inner().gateway {
+
+                #[inline]
+                pub fn role(&self) -> Role;
+
+                #[inline]
+                pub fn config(&self) -> &GatewayConfig;
+            }
+        }
+
+        #[allow(clippy::let_and_return)]
+        pub fn new(
+            query_id: QueryId,
+            config: GatewayConfig,
+            roles: RoleAssignment,
+            transport: TransportImpl,
+        ) -> Self {
+            let version = Arc::new(AtomicUsize::default());
+            let r = Self::wrap(
+                Arc::downgrade(&version),
+                InstrumentedGateway {
+                    gateway: Gateway::new(query_id, config, roles, transport),
+                    _sn: version,
+                },
+            );
+
+            // spawn the watcher
+            #[cfg(not(feature = "shuttle"))]
+            {
+                use tracing::Instrument;
+
+                tokio::spawn({
+                    let gateway = r.to_observed();
+                    async move {
+                        let mut last_sn_seen = 0;
+                        loop {
+                            ::tokio::time::sleep(config.progress_check_interval).await;
+                            let now = gateway.get_sn().upgrade().map(|v| v.load(Ordering::Relaxed));
+                            if let Some(now) = now {
+                                if now == last_sn_seen {
+                                    if let Some(state) = gateway.get_state() {
+                                        tracing::warn!(sn = now, state = ?state, "Helper is stalled");
+                                    }
+                                }
+                                last_sn_seen = now;
+                            } else {
+                                break;
+                            }
+                        }
+                    }.instrument(tracing::info_span!("stall_detector", role = ?r.role()))
+                });
+            }
+
+            r
+        }
+
+        #[must_use]
+        pub fn get_sender<M: Message>(
+            &self,
+            channel_id: &ChannelId,
+            total_records: TotalRecords,
+        ) -> SendingEnd<M> {
+            Observed::wrap(
+                Weak::clone(self.get_sn()),
+                self.inner().gateway.get_sender(channel_id, total_records),
+            )
+        }
+
+        #[must_use]
+        pub fn get_receiver<M: Message>(&self, channel_id: &ChannelId) -> ReceivingEnd<M> {
+            Observed::wrap(
+                Weak::clone(self.get_sn()),
+                self.inner().gateway.get_receiver(channel_id),
+            )
+        }
+
+        pub fn to_observed(&self) -> Observed<Weak<State>> {
+            // todo: inner.inner
+            Observed::wrap(
+                Weak::clone(self.get_sn()),
+                Arc::downgrade(&self.inner().gateway.inner),
+            )
+        }
+    }
+
+    pub struct GatewayWaitingTasks<S, R> {
+        senders_state: Option<S>,
+        receivers_state: Option<R>,
+    }
+
+    impl<S: Debug, R: Debug> Debug for GatewayWaitingTasks<S, R> {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            if let Some(senders_state) = &self.senders_state {
+                write!(f, "\n{{{senders_state:?}\n}}")?;
+            }
+            if let Some(receivers_state) = &self.receivers_state {
+                write!(f, "\n{{{receivers_state:?}\n}}")?;
+            }
+
+            Ok(())
+        }
+    }
+
+    impl ObserveState for Weak<State> {
+        type State = GatewayWaitingTasks<send::WaitingTasks, receive::WaitingTasks>;
+
+        fn get_state(&self) -> Option<Self::State> {
+            self.upgrade().and_then(|state| {
+                match (state.senders.get_state(), state.receivers.get_state()) {
+                    (None, None) => None,
+                    (senders_state, receivers_state) => Some(Self::State {
+                        senders_state,
+                        receivers_state,
+                    }),
+                }
+            })
+        }
+    }
+}
+
+mod receive {
+    use std::{
+        collections::BTreeMap,
+        fmt::{Debug, Formatter},
+    };
+
+    use super::*;
+    use crate::{
+        helpers::{
+            error::Error,
+            gateway::{receive::GatewayReceivers, ReceivingEnd},
+            ChannelId, Message,
+        },
+        protocol::RecordId,
+    };
+
+    impl<M: Message> Observed<ReceivingEnd<M>> {
+        delegate::delegate! {
+            to { self.advance(); self.inner() } {
+                #[inline]
+                pub async fn receive(&self, record_id: RecordId) -> Result<M, Error>;
+            }
+        }
+    }
+
+    pub struct WaitingTasks(BTreeMap<ChannelId, Vec<String>>);
+
+    impl Debug for WaitingTasks {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            for (channel, records) in &self.0 {
+                write!(
+                    f,
+                    "\n\"{:?}\", from={:?}. Waiting to receive records {:?}.",
+                    channel.gate, channel.role, records
+                )?;
+            }
+
+            Ok(())
+        }
+    }
+
+    impl ObserveState for GatewayReceivers {
+        type State = WaitingTasks;
+
+        fn get_state(&self) -> Option<Self::State> {
+            let mut map = BTreeMap::default();
+            for entry in &self.inner {
+                let channel = entry.key();
+                if let Some(waiting) = super::to_ranges(entry.value().waiting()).get_state() {
+                    map.insert(channel.clone(), waiting);
+                }
+            }
+
+            (!map.is_empty()).then_some(WaitingTasks(map))
+        }
+    }
+}
+
+mod send {
+    use std::{
+        collections::BTreeMap,
+        fmt::{Debug, Formatter},
+    };
+
+    use super::*;
+    use crate::{
+        helpers::{
+            error::Error,
+            gateway::send::{GatewaySender, GatewaySenders},
+            ChannelId, Message, TotalRecords,
+        },
+        protocol::RecordId,
+    };
+
+    impl<M: Message> Observed<crate::helpers::gateway::send::SendingEnd<M>> {
+        delegate::delegate! {
+            to { self.advance(); self.inner() } {
+                #[inline]
+                pub async fn send(&self, record_id: RecordId, msg: M) -> Result<(), Error>;
+            }
+        }
+    }
+
+    pub struct WaitingTasks(BTreeMap<ChannelId, (TotalRecords, Vec<String>)>);
+
+    impl Debug for WaitingTasks {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            for (channel, (total, records)) in &self.0 {
+                write!(
+                    f,
+                    "\n\"{:?}\", to={:?}. Waiting to send records {:?} out of {total:?}.",
+                    channel.gate, channel.role, records
+                )?;
+            }
+
+            Ok(())
+        }
+    }
+
+    impl ObserveState for GatewaySenders {
+        type State = WaitingTasks;
+
+        fn get_state(&self) -> Option<Self::State> {
+            let mut state = BTreeMap::new();
+            for entry in &self.inner {
+                let channel = entry.key();
+                let sender = entry.value();
+                if let Some(sender_state) = sender.get_state() {
+                    state.insert(channel.clone(), (sender.total_records(), sender_state));
+                }
+            }
+
+            (!state.is_empty()).then_some(WaitingTasks(state))
+        }
+    }
+
+    impl ObserveState for GatewaySender {
+        type State = Vec<String>;
+
+        fn get_state(&self) -> Option<Self::State> {
+            let waiting_indices = self.waiting();
+            super::to_ranges(waiting_indices).get_state()
+        }
+    }
+}
+
+/// Converts a vector of numbers into a vector of ranges.
+/// For example, [1, 2, 3, 4, 5, 7, 9, 10, 11] produces [(1..=5), (7..=7), (9..=11)].
+fn to_ranges(nums: Vec<usize>) -> Vec<std::ops::RangeInclusive<usize>> {
+    nums.into_iter()
+        .fold(Vec::<RangeInclusive<usize>>::new(), |mut ranges, num| {
+            if let Some(last_range) = ranges.last_mut().filter(|r| *r.end() == num - 1) {
+                *last_range = *last_range.start()..=num;
+            } else {
+                ranges.push(num..=num);
+            }
+            ranges
+        })
+}
+
+/// Range formatter that prints one-element wide ranges as single numbers.
+impl<U> ObserveState for Vec<RangeInclusive<U>>
+where
+    U: Copy + Display + Eq + PartialOrd + Ord + Sub<Output = U> + From<u8>,
+{
+    type State = Vec<String>;
+    fn get_state(&self) -> Option<Self::State> {
+        let r = self
+            .iter()
+            .map(
+                |range| match (*range.end() - *range.start()).cmp(&U::from(1)) {
+                    std::cmp::Ordering::Less => format!("{}", range.start()),
+                    std::cmp::Ordering::Equal => format!("[{}, {}]", range.start(), range.end()),
+                    std::cmp::Ordering::Greater => format!("[{}..{}]", range.start(), range.end()),
+                },
+            )
+            .collect::<Vec<_>>();
+
+        (!r.is_empty()).then_some(r)
+    }
+}
diff --git a/src/helpers/gateway/transport.rs b/src/helpers/gateway/transport.rs
index 94563b3c0..8c90a29ee 100644
--- a/src/helpers/gateway/transport.rs
+++ b/src/helpers/gateway/transport.rs
@@ -2,7 +2,7 @@ use crate::{
     helpers::{
         buffers::UnorderedReceiver,
         gateway::{receive::UR, send::GatewaySendStream},
-        ChannelId, GatewayConfig, Role, RoleAssignment, RouteId, Transport,
+        ChannelId, GatewayConfig, Role, RoleAssignment, RouteId, Transport, TransportImpl,
     },
     protocol::QueryId,
 };
@@ -12,19 +12,19 @@ use crate::{
 ///
 /// [`HelperIdentity`]: crate::helpers::HelperIdentity
 #[derive(Clone)]
-pub(super) struct RoleResolvingTransport<T> {
+pub(super) struct RoleResolvingTransport {
     pub query_id: QueryId,
     pub roles: RoleAssignment,
     pub config: GatewayConfig,
-    pub inner: T,
+    pub inner: TransportImpl,
 }
 
-impl<T: Transport> RoleResolvingTransport<T> {
+impl RoleResolvingTransport {
     pub(crate) async fn send(
         &self,
         channel_id: &ChannelId,
         data: GatewaySendStream,
-    ) -> Result<(), T::Error> {
+    ) -> Result<(), <TransportImpl as Transport>::Error> {
         let dest_identity = self.roles.identity(channel_id.role);
         assert_ne!(
             dest_identity,
@@ -41,7 +41,7 @@ impl<T: Transport> RoleResolvingTransport<T> {
             .await
     }
 
-    pub(crate) fn receive(&self, channel_id: &ChannelId) -> UR<T> {
+    pub(crate) fn receive(&self, channel_id: &ChannelId) -> UR {
         let peer = self.roles.identity(channel_id.role);
         assert_ne!(
             peer,
diff --git a/src/helpers/mod.rs b/src/helpers/mod.rs
index 1c510485e..ff2f7767f 100644
--- a/src/helpers/mod.rs
+++ b/src/helpers/mod.rs
@@ -3,6 +3,8 @@ use std::{
     num::NonZeroUsize,
 };
 
+use generic_array::GenericArray;
+
 mod buffers;
 mod error;
 mod gateway;
@@ -15,11 +17,33 @@ use std::ops::{Index, IndexMut};
 #[cfg(test)]
 pub use buffers::OrderingSender;
 pub use error::{Error, Result};
+
+#[cfg(feature = "stall-detection")]
+mod gateway_exports {
+    use crate::helpers::{
+        gateway,
+        gateway::{stall_detection::Observed, InstrumentedGateway},
+    };
+
+    pub type Gateway = Observed<InstrumentedGateway>;
+    pub type SendingEnd<M> = Observed<gateway::SendingEnd<M>>;
+    pub type ReceivingEnd<M> = Observed<gateway::ReceivingEnd<M>>;
+}
+
+#[cfg(not(feature = "stall-detection"))]
+mod gateway_exports {
+    use crate::helpers::gateway;
+
+    pub type Gateway = gateway::Gateway;
+    pub type SendingEnd<M> = gateway::SendingEnd<M>;
+    pub type ReceivingEnd<M> = gateway::ReceivingEnd<M>;
+}
+
+pub use gateway::GatewayConfig;
 // TODO: this type should only be available within infra. Right now several infra modules
 // are exposed at the root level. That makes it impossible to have a proper hierarchy here.
-pub use gateway::{Gateway, TransportError, TransportImpl};
-pub use gateway::{GatewayConfig, ReceivingEnd, SendingEnd};
-use generic_array::GenericArray;
+pub use gateway::{TransportError, TransportImpl};
+pub use gateway_exports::{Gateway, ReceivingEnd, SendingEnd};
 pub use prss_protocol::negotiate as negotiate_prss;
 #[cfg(feature = "web-app")]
 pub use transport::WrappedAxumBodyStream;
@@ -195,7 +219,7 @@ impl<T> IndexMut<HelperIdentity> for Vec<T> {
 /// may be `H2` or `H3`.
 /// Each helper instance must be able to take any role, but once the role is assigned, it cannot
 /// be changed for the remainder of the query.
-#[derive(Copy, Clone, Debug, PartialEq, Hash, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "cli", derive(clap::ValueEnum))]
 #[cfg_attr(
     feature = "enable-serde",
@@ -384,7 +408,7 @@ impl TryFrom<[Role; 3]> for RoleAssignment {
 
 /// Combination of helper role and step that uniquely identifies a single channel of communication
 /// between two helpers.
-#[derive(Clone, Eq, PartialEq, Hash)]
+#[derive(Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub struct ChannelId {
     pub role: Role,
     // TODO: step could be either reference or owned value. references are convenient to use inside
diff --git a/src/helpers/prss_protocol.rs b/src/helpers/prss_protocol.rs
index e44fec8ed..4dddd21fb 100644
--- a/src/helpers/prss_protocol.rs
+++ b/src/helpers/prss_protocol.rs
@@ -3,7 +3,7 @@ use rand_core::{CryptoRng, RngCore};
 use x25519_dalek::PublicKey;
 
 use crate::{
-    helpers::{ChannelId, Direction, Error, Gateway, TotalRecords, Transport},
+    helpers::{ChannelId, Direction, Error, Gateway, TotalRecords},
     protocol::{
         prss,
         step::{Gate, Step, StepNarrow},
@@ -24,8 +24,8 @@ impl Step for PrssExchangeStep {}
 /// establish the prss endpoint by exchanging public keys with the other helpers
 /// # Errors
 /// if communication with other helpers fails
-pub async fn negotiate<T: Transport, R: RngCore + CryptoRng>(
-    gateway: &Gateway<T>,
+pub async fn negotiate<R: RngCore + CryptoRng>(
+    gateway: &Gateway,
     gate: &Gate,
     rng: &mut R,
 ) -> Result<prss::Endpoint, Error> {
diff --git a/src/lib.rs b/src/lib.rs
index 340601adc..17e78fcfa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -124,13 +124,21 @@ pub(crate) mod test_executor {
     }
 }
 
-#[cfg(all(feature = "in-memory-infra", feature = "real-world-infra"))]
-compile_error!("feature \"in-memory-infra\" and feature \"real-world-infra\" cannot be enabled at the same time");
+macro_rules! mutually_incompatible {
+    ($feature1:literal,$feature2:literal) => {
+        #[cfg(all(feature = $feature1, feature = $feature2))]
+        compile_error!(concat!(
+            "feature \"",
+            $feature1,
+            "\" and feature \"",
+            $feature2,
+            "\" can't be enabled at the same time"
+        ));
+    };
+}
 
-#[cfg(all(feature = "compact-gate", feature = "descriptive-date"))]
-compile_error!(
-    "feature \"compact-gate\" and feature \"descriptive-gate\" cannot be enabled at the same time"
-);
+mutually_incompatible!("in-memory-infra", "real-world-infra");
+mutually_incompatible!("compact-gate", "descriptive-gate");
 
 #[cfg(all(not(feature = "compact-gate"), not(feature = "descriptive-gate")))]
 compile_error!("feature \"compact-gate\" or \"descriptive-gate\" must be enabled");
diff --git a/src/protocol/step/compact.rs b/src/protocol/step/compact.rs
index 32cdc1886..fb6fd873f 100644
--- a/src/protocol/step/compact.rs
+++ b/src/protocol/step/compact.rs
@@ -5,7 +5,7 @@ use ipa_macros::Gate;
 use super::StepNarrow;
 use crate::helpers::{prss_protocol::PrssExchangeStep, query::QueryType};
 
-#[derive(Gate, Clone, Hash, PartialEq, Eq, Default)]
+#[derive(Gate, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]
 #[cfg_attr(
     feature = "enable-serde",
     derive(serde::Deserialize),
diff --git a/src/protocol/step/descriptive.rs b/src/protocol/step/descriptive.rs
index 4f41a4881..dc13e40a1 100644
--- a/src/protocol/step/descriptive.rs
+++ b/src/protocol/step/descriptive.rs
@@ -22,7 +22,7 @@ use crate::telemetry::{labels::STEP, metrics::STEP_NARROWED};
 /// Step "a" would be executed with a context identifier of "protocol/a", which it
 ///  would `narrow()` into "protocol/a/x" and "protocol/a/y" to produce a final set
 /// of identifiers: ".../a/x", ".../a/y", ".../b", and ".../c".
-#[derive(Clone, Hash, PartialEq, Eq)]
+#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 #[cfg_attr(
     feature = "enable-serde",
     derive(serde::Deserialize),

From 3a5c130e66abd213f22fd1db1c931349c6ebe09a Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Tue, 7 Nov 2023 16:50:39 +0800
Subject: [PATCH 099/105] use min_events_per_user and revert back to using the
 rng to set the number of events a user can generate

---
 benches/oneshot/ipa.rs        | 33 ++++++++++++++++++++-------------
 src/protocol/ipa/mod.rs       |  2 ++
 src/test_fixture/event_gen.rs | 29 ++++++++++++++++++++++++++---
 3 files changed, 48 insertions(+), 16 deletions(-)

diff --git a/benches/oneshot/ipa.rs b/benches/oneshot/ipa.rs
index 7b86af1a9..4dcb0db3b 100644
--- a/benches/oneshot/ipa.rs
+++ b/benches/oneshot/ipa.rs
@@ -111,25 +111,32 @@ async fn run(args: Args) -> Result<(), Error> {
         q = args.query_size
     );
     let rng = StdRng::seed_from_u64(seed);
-    let (user_count, max_events_per_user, query_size) = if args.oprf && cfg!(feature = "step-trace")
-    {
-        // For the steps collection, OPRF mode requires a single user with the same number
-        // of dynamic steps as defined for `UserNthRowStep::Row`.
-        (NonZeroU64::new(1).unwrap(), 64, 64)
-    } else {
-        (
-            EventGeneratorConfig::default().user_count,
-            args.records_per_user,
-            args.query_size,
-        )
-    };
+    let (user_count, min_events_per_user, max_events_per_user, query_size) =
+        if args.oprf && cfg!(feature = "step-trace") {
+            // For the steps collection, OPRF mode requires a single user with the same number
+            // of dynamic steps as defined for `UserNthRowStep::Row`.
+            (
+                NonZeroU64::new(1).unwrap(),
+                NonZeroU32::new(64).unwrap(),
+                NonZeroU32::new(64).unwrap(),
+                64,
+            )
+        } else {
+            (
+                EventGeneratorConfig::default().user_count,
+                EventGeneratorConfig::default().min_events_per_user,
+                NonZeroU32::new(args.records_per_user).unwrap(),
+                args.query_size,
+            )
+        };
     let raw_data = EventGenerator::with_config(
         rng,
         EventGeneratorConfig {
             user_count,
             max_trigger_value: NonZeroU32::try_from(args.max_trigger_value).unwrap(),
             max_breakdown_key: NonZeroU32::try_from(args.breakdown_keys).unwrap(),
-            max_events_per_user: NonZeroU32::try_from(max_events_per_user).unwrap(),
+            min_events_per_user,
+            max_events_per_user,
             ..Default::default()
         },
     )
diff --git a/src/protocol/ipa/mod.rs b/src/protocol/ipa/mod.rs
index bac3d6e82..5191c74da 100644
--- a/src/protocol/ipa/mod.rs
+++ b/src/protocol/ipa/mod.rs
@@ -782,6 +782,7 @@ pub mod tests {
         const MAX_BREAKDOWN_KEY: u32 = 32;
         const MAX_TRIGGER_VALUE: u32 = 5;
         const NUM_USERS: u32 = 8;
+        const MIN_RECORDS_PER_USER: u32 = 1;
         const MAX_RECORDS_PER_USER: u32 = 8;
         const NUM_MULTI_BITS: u32 = 3;
         const ATTRIBUTION_WINDOW_SECONDS: Option<NonZeroU32> = NonZeroU32::new(86_400);
@@ -803,6 +804,7 @@ pub mod tests {
                 u64::from(NUM_USERS),
                 MAX_TRIGGER_VALUE,
                 MAX_BREAKDOWN_KEY,
+                MIN_RECORDS_PER_USER,
                 MAX_RECORDS_PER_USER,
             ),
         )
diff --git a/src/test_fixture/event_gen.rs b/src/test_fixture/event_gen.rs
index 8b9651425..1ee75ef56 100644
--- a/src/test_fixture/event_gen.rs
+++ b/src/test_fixture/event_gen.rs
@@ -45,6 +45,8 @@ pub struct Config {
     pub max_breakdown_key: NonZeroU32,
     #[cfg_attr(feature = "clap", arg(long, default_value = "10"))]
     pub max_events_per_user: NonZeroU32,
+    #[cfg_attr(feature = "clap", arg(long, default_value = "1"))]
+    pub min_events_per_user: NonZeroU32,
     /// Indicates the types of reports that will appear in the output. Possible values
     /// are: only impressions, only conversions or both.
     #[cfg_attr(feature = "clap", arg(value_enum, long, default_value_t = ReportFilter::All))]
@@ -66,7 +68,7 @@ fn validate_probability(value: &str) -> Result<f32, String> {
 
 impl Default for Config {
     fn default() -> Self {
-        Self::new(1_000_000_000_000, 5, 20, 50)
+        Self::new(1_000_000_000_000, 5, 20, 1, 50)
     }
 }
 
@@ -80,12 +82,15 @@ impl Config {
         user_count: u64,
         max_trigger_value: u32,
         max_breakdown_key: u32,
+        min_events_per_user: u32,
         max_events_per_user: u32,
     ) -> Self {
+        assert!(min_events_per_user < max_events_per_user);
         Self {
             user_count: NonZeroU64::try_from(user_count).unwrap(),
             max_trigger_value: NonZeroU32::try_from(max_trigger_value).unwrap(),
             max_breakdown_key: NonZeroU32::try_from(max_breakdown_key).unwrap(),
+            min_events_per_user: NonZeroU32::try_from(min_events_per_user).unwrap(),
             max_events_per_user: NonZeroU32::try_from(max_events_per_user).unwrap(),
             report_filter: ReportFilter::All,
             conversion_probability: None,
@@ -226,7 +231,13 @@ impl<R: Rng> EventGenerator<R> {
             );
             if valid(next) {
                 self.used.insert(next);
-                break UserStats::new(next, self.config.max_events_per_user.get());
+                break UserStats::new(
+                    next,
+                    self.rng.gen_range(
+                        self.config.min_events_per_user.get()
+                            ..=self.config.max_events_per_user.get(),
+                    ),
+                );
             }
         })
     }
@@ -280,6 +291,7 @@ mod tests {
             thread_rng(),
             Config {
                 user_count: NonZeroU64::new(10).unwrap(),
+                min_events_per_user: NonZeroU32::new(10).unwrap(),
                 max_events_per_user: NonZeroU32::new(10).unwrap(),
                 ..Config::default()
             },
@@ -357,14 +369,25 @@ mod tests {
                 1..u32::MAX,
                 1..u32::MAX,
                 1..u32::MAX,
+                1..u32::MAX,
                 report_filter_strategy(),
             )
                 .prop_map(
-                    |(max_trigger_value, max_breakdown_key, max_events_per_user, report_filter)| {
+                    |(
+                        max_trigger_value,
+                        max_breakdown_key,
+                        mut min_events_per_user,
+                        mut max_events_per_user,
+                        report_filter,
+                    )| {
+                        if min_events_per_user > max_events_per_user {
+                            std::mem::swap(&mut min_events_per_user, &mut max_events_per_user);
+                        }
                         Config {
                             user_count: NonZeroU64::new(10_000).unwrap(),
                             max_trigger_value: NonZeroU32::new(max_trigger_value).unwrap(),
                             max_breakdown_key: NonZeroU32::new(max_breakdown_key).unwrap(),
+                            min_events_per_user: NonZeroU32::new(min_events_per_user).unwrap(),
                             max_events_per_user: NonZeroU32::new(max_events_per_user).unwrap(),
                             report_filter,
                             conversion_probability: match report_filter {

From 17af9244be6675b3c000d457f294a2cffa8d7517 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Tue, 7 Nov 2023 00:41:15 +0800
Subject: [PATCH 100/105] debugging stall in streaming OPRF ipa

---
 src/protocol/ipa_prf/prf_sharding/mod.rs | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/src/protocol/ipa_prf/prf_sharding/mod.rs b/src/protocol/ipa_prf/prf_sharding/mod.rs
index db62c95e0..29c29385d 100644
--- a/src/protocol/ipa_prf/prf_sharding/mod.rs
+++ b/src/protocol/ipa_prf/prf_sharding/mod.rs
@@ -102,6 +102,7 @@ impl InputsRequiredFromPrevRow {
     pub async fn compute_row_with_previous<C, BK, TV, TS>(
         &mut self,
         ctx: C,
+        depth: usize,
         record_id: RecordId,
         input_row: &PrfShardedIpaInputRow<BK, TV, TS>,
         num_saturating_sum_bits: usize,
@@ -113,6 +114,7 @@ impl InputsRequiredFromPrevRow {
         TV: GaloisField,
         TS: GaloisField,
     {
+        println!("depth: {}, record_id: {}", depth, usize::from(record_id));
         let (bd_key, tv, timestamp) = (
             input_row.breakdown_key_bits(),
             input_row.trigger_value_bits(),
@@ -349,6 +351,8 @@ where
 /// Takes an input stream of `PrfShardedIpaInputRecordRow` which is assumed to have all records with a given PRF adjacent
 /// and converts it into a stream of vectors of `PrfShardedIpaInputRecordRow` having the same PRF.
 ///
+/// Filters out any users that only have a single row, since they will produce no attributed conversions.
+///
 fn chunk_rows_by_user<IS, BK, TV, TS>(
     input_stream: IS,
     first_row: PrfShardedIpaInputRow<BK, TV, TS>,
@@ -361,13 +365,18 @@ where
 {
     unfold(Some((input_stream, first_row)), |state| async move {
         let (mut s, last_row) = state?;
-        let last_row_prf = last_row.prf_of_match_key;
+        let mut last_row_prf = last_row.prf_of_match_key;
         let mut current_chunk = vec![last_row];
         while let Some(row) = s.next().await {
             if row.prf_of_match_key == last_row_prf {
                 current_chunk.push(row);
             } else {
-                return Some((current_chunk, Some((s, row))));
+                if current_chunk.len() > 1 {
+                    return Some((current_chunk, Some((s, row))));
+                } else {
+                    last_row_prf = row.prf_of_match_key;
+                    current_chunk = vec![row];
+                }
             }
         }
         Some((current_chunk, None))
@@ -413,6 +422,8 @@ where
     assert!(BK::BITS > 0);
     assert!(TS::BITS > 0);
 
+    println!("histogram: {:?}", histogram);
+
     // Get the validator and context to use for Gf2 multiplication operations
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
@@ -458,16 +469,15 @@ where
     }));
 
     // Execute all of the async futures (sequentially), and flatten the result
-    let collected_per_user_results = stream_of_per_user_circuits.collect::<Vec<_>>().await;
-    let per_user_attribution_outputs = sh_ctx.parallel_join(collected_per_user_results).await?;
-    let flattenned_stream = per_user_attribution_outputs.into_iter().flatten();
+    let flattenned_stream = seq_join(sh_ctx.active_work(), stream_of_per_user_circuits)
+        .flat_map(|x| stream_iter(x.unwrap()));
 
     // modulus convert breakdown keys and trigger values
     let converted_bks_and_tvs = convert_bits(
         prime_field_ctx
             .narrow(&Step::ModulusConvertBreakdownKeyBitsAndTriggerValues)
             .set_total_records(num_outputs),
-        stream_iter(flattenned_stream),
+        flattenned_stream,
         0..BK::BITS + TV::BITS,
     );
 
@@ -543,6 +553,7 @@ where
         let capped_attribution_outputs = prev_row_inputs
             .compute_row_with_previous(
                 ctx_for_this_row_depth,
+                i,
                 record_id_for_this_row_depth,
                 row,
                 num_saturating_sum_bits,

From 8e8b0e4af6847e04aeb29461ab1cce59df13a0a8 Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Tue, 7 Nov 2023 21:48:38 +0800
Subject: [PATCH 101/105] OMG it works

---
 src/protocol/ipa_prf/prf_sharding/mod.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/protocol/ipa_prf/prf_sharding/mod.rs b/src/protocol/ipa_prf/prf_sharding/mod.rs
index 29c29385d..636a41598 100644
--- a/src/protocol/ipa_prf/prf_sharding/mod.rs
+++ b/src/protocol/ipa_prf/prf_sharding/mod.rs
@@ -102,7 +102,6 @@ impl InputsRequiredFromPrevRow {
     pub async fn compute_row_with_previous<C, BK, TV, TS>(
         &mut self,
         ctx: C,
-        depth: usize,
         record_id: RecordId,
         input_row: &PrfShardedIpaInputRow<BK, TV, TS>,
         num_saturating_sum_bits: usize,
@@ -114,7 +113,6 @@ impl InputsRequiredFromPrevRow {
         TV: GaloisField,
         TS: GaloisField,
     {
-        println!("depth: {}, record_id: {}", depth, usize::from(record_id));
         let (bd_key, tv, timestamp) = (
             input_row.breakdown_key_bits(),
             input_row.trigger_value_bits(),
@@ -422,8 +420,6 @@ where
     assert!(BK::BITS > 0);
     assert!(TS::BITS > 0);
 
-    println!("histogram: {:?}", histogram);
-
     // Get the validator and context to use for Gf2 multiplication operations
     let binary_validator = sh_ctx.narrow(&Step::BinaryValidator).validator::<Gf2>();
     let binary_m_ctx = binary_validator.context();
@@ -446,8 +442,11 @@ where
     let first_row = first_row.unwrap();
     let rows_chunked_by_user = chunk_rows_by_user(input_stream, first_row);
 
+    let mut collected = rows_chunked_by_user.collect::<Vec<_>>().await;
+    collected.sort_by(|a, b| std::cmp::Ord::cmp(&b.len(), &a.len()));
+
     // Convert to a stream of async futures that represent the result of executing the per-user circuit
-    let stream_of_per_user_circuits = pin!(rows_chunked_by_user.then(|rows_for_user| {
+    let stream_of_per_user_circuits = pin!(stream_iter(collected).then(|rows_for_user| {
         let num_user_rows = rows_for_user.len();
         let contexts = ctx_for_row_number[..num_user_rows - 1].to_owned();
         let record_ids = record_id_for_row_depth[..num_user_rows].to_owned();
@@ -553,7 +552,6 @@ where
         let capped_attribution_outputs = prev_row_inputs
             .compute_row_with_previous(
                 ctx_for_this_row_depth,
-                i,
                 record_id_for_this_row_depth,
                 row,
                 num_saturating_sum_bits,

From 50ef10e7c4da378b36ac4233a7419624b990d27b Mon Sep 17 00:00:00 2001
From: Ben Savage <btsavage@fb.com>
Date: Tue, 7 Nov 2023 21:55:38 +0800
Subject: [PATCH 102/105] making clippy happy

---
 src/protocol/ipa_prf/prf_sharding/mod.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/protocol/ipa_prf/prf_sharding/mod.rs b/src/protocol/ipa_prf/prf_sharding/mod.rs
index 636a41598..5e0ae01d5 100644
--- a/src/protocol/ipa_prf/prf_sharding/mod.rs
+++ b/src/protocol/ipa_prf/prf_sharding/mod.rs
@@ -368,13 +368,11 @@ where
         while let Some(row) = s.next().await {
             if row.prf_of_match_key == last_row_prf {
                 current_chunk.push(row);
+            } else if current_chunk.len() > 1 {
+                return Some((current_chunk, Some((s, row))));
             } else {
-                if current_chunk.len() > 1 {
-                    return Some((current_chunk, Some((s, row))));
-                } else {
-                    last_row_prf = row.prf_of_match_key;
-                    current_chunk = vec![row];
-                }
+                last_row_prf = row.prf_of_match_key;
+                current_chunk = vec![row];
             }
         }
         Some((current_chunk, None))

From fa1f3948ea42aaa176d494575a682ccba8f5e39c Mon Sep 17 00:00:00 2001
From: Alex Koshelev <koshelev@meta.com>
Date: Tue, 7 Nov 2023 13:15:09 -0800
Subject: [PATCH 103/105] Remove compact gate tests from basic checks

Its great that we run them twice, but it is probably [too much](https://github.com/private-attribution/ipa/actions/runs/6789188348/job/18458850996). Run them once as part of additional checks step
---
 .github/workflows/check.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml
index 15c5d5b57..5224f9abd 100644
--- a/.github/workflows/check.yml
+++ b/.github/workflows/check.yml
@@ -67,9 +67,6 @@ jobs:
       - name: Run Web Tests
         run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture descriptive-gate"
 
-      - name: Run compact gate tests
-        run: cargo test --no-default-features --features "cli web-app real-world-infra test-fixture compact-gate"
-
   release:
     name: Release builds and tests
     runs-on: ubuntu-latest

From 650cb4b37b4db8f4476551598ecb55091b225c24 Mon Sep 17 00:00:00 2001
From: Artem Ignatyev <230930+cryo28@users.noreply.github.com>
Date: Tue, 7 Nov 2023 17:30:17 -0600
Subject: [PATCH 104/105] [oprf][shuffle] OPRF Shuffle using a 2-round
 4-message shuffle protocol (#816)

* [oprf][shuffle] OPRF Shuffle using a 2-round 4-message shuffle protocol

Implementation of the protocol (not sharded)

---------

Co-authored-by: Artem Ignatyev <aignatyev@meta.com>
Co-authored-by: Alex Koshelev <koshelev@meta.com>
---
 src/ff/galois_field.rs                        |  27 +-
 .../transport/{query.rs => query/mod.rs}      |   2 +
 src/helpers/transport/query/oprf_shuffle.rs   |   5 +
 src/lib.rs                                    |   1 +
 .../apply.rs => basics/apply_permutation.rs}  |   0
 src/protocol/basics/mod.rs                    |   1 +
 src/protocol/ipa_prf/mod.rs                   |   2 +
 src/protocol/ipa_prf/shuffle.rs               | 390 ++++++++++++++++++
 src/protocol/sort/apply_sort/mod.rs           |   7 +-
 src/protocol/sort/apply_sort/shuffle.rs       |   6 +-
 src/protocol/sort/compose.rs                  |  10 +-
 src/protocol/sort/mod.rs                      |   1 -
 src/protocol/sort/secureapplyinv.rs           |  10 +-
 src/protocol/sort/shuffle.rs                  |  15 +-
 src/query/runner/mod.rs                       |   1 -
 .../replicated/semi_honest/additive_share.rs  |   1 -
 16 files changed, 449 insertions(+), 30 deletions(-)
 rename src/helpers/transport/{query.rs => query/mod.rs} (99%)
 create mode 100644 src/helpers/transport/query/oprf_shuffle.rs
 rename src/protocol/{sort/apply.rs => basics/apply_permutation.rs} (100%)
 create mode 100644 src/protocol/ipa_prf/shuffle.rs

diff --git a/src/ff/galois_field.rs b/src/ff/galois_field.rs
index 633e1fd72..d7d6e8312 100644
--- a/src/ff/galois_field.rs
+++ b/src/ff/galois_field.rs
@@ -194,10 +194,31 @@ macro_rules! bit_array_impl {
             // = 01011001
             // Since the coefficients are in GF(2), we can just XOR these bitwise representations.
             // Note for x^7 + x^7 = 0 because 1 + 1 = 0 in GF(2)
-            impl std::ops::Add for $name {
+            impl <'a, 'b> std::ops::Add<&'b $name> for &'a $name {
+                type Output = $name;
+                fn add(self, rhs: &'b $name) -> Self::Output {
+                    $name(self.0 ^ rhs.0)
+                }
+            }
+
+            impl std::ops::Add<&$name> for $name {
+                type Output = Self;
+                fn add(self, rhs: &$name) -> Self::Output {
+                    std::ops::Add::add(&self, rhs)
+                }
+            }
+
+            impl std::ops::Add<$name> for &$name {
+                type Output = $name;
+                fn add(self, rhs: $name) -> Self::Output {
+                    std::ops::Add::add(self, &rhs)
+                }
+            }
+
+            impl std::ops::Add<$name> for $name {
                 type Output = Self;
-                fn add(self, rhs: Self) -> Self::Output {
-                    Self(self.0 ^ rhs.0)
+                fn add(self, rhs: $name) -> Self::Output {
+                    std::ops::Add::add(&self, &rhs)
                 }
             }
 
diff --git a/src/helpers/transport/query.rs b/src/helpers/transport/query/mod.rs
similarity index 99%
rename from src/helpers/transport/query.rs
rename to src/helpers/transport/query/mod.rs
index 6bb7a9ed9..15a8a5035 100644
--- a/src/helpers/transport/query.rs
+++ b/src/helpers/transport/query/mod.rs
@@ -1,3 +1,5 @@
+pub mod oprf_shuffle;
+
 use std::{
     fmt::{Debug, Display, Formatter},
     num::NonZeroU32,
diff --git a/src/helpers/transport/query/oprf_shuffle.rs b/src/helpers/transport/query/oprf_shuffle.rs
new file mode 100644
index 000000000..c39242902
--- /dev/null
+++ b/src/helpers/transport/query/oprf_shuffle.rs
@@ -0,0 +1,5 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct QueryConfig {}
diff --git a/src/lib.rs b/src/lib.rs
index 17e78fcfa..a342dab43 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,6 +16,7 @@ pub mod error;
 pub mod ff;
 pub mod helpers;
 pub mod hpke;
+
 #[cfg(feature = "web-app")]
 pub mod net;
 pub mod protocol;
diff --git a/src/protocol/sort/apply.rs b/src/protocol/basics/apply_permutation.rs
similarity index 100%
rename from src/protocol/sort/apply.rs
rename to src/protocol/basics/apply_permutation.rs
diff --git a/src/protocol/basics/mod.rs b/src/protocol/basics/mod.rs
index 4e3def06b..a5d0f58a9 100644
--- a/src/protocol/basics/mod.rs
+++ b/src/protocol/basics/mod.rs
@@ -1,3 +1,4 @@
+pub mod apply_permutation;
 pub mod check_zero;
 mod if_else;
 pub(crate) mod mul;
diff --git a/src/protocol/ipa_prf/mod.rs b/src/protocol/ipa_prf/mod.rs
index f3ee4a5f9..108f9288d 100644
--- a/src/protocol/ipa_prf/mod.rs
+++ b/src/protocol/ipa_prf/mod.rs
@@ -1,3 +1,5 @@
 #[cfg(feature = "descriptive-gate")]
 pub mod prf_eval;
 pub mod prf_sharding;
+#[cfg(feature = "descriptive-gate")]
+pub mod shuffle;
diff --git a/src/protocol/ipa_prf/shuffle.rs b/src/protocol/ipa_prf/shuffle.rs
new file mode 100644
index 000000000..77efcde8e
--- /dev/null
+++ b/src/protocol/ipa_prf/shuffle.rs
@@ -0,0 +1,390 @@
+use std::ops::{Add, AddAssign};
+
+use futures::future;
+use ipa_macros::Step;
+use rand::{distributions::Standard, prelude::Distribution, seq::SliceRandom, Rng};
+
+use super::super::{context::Context, RecordId};
+use crate::{
+    error::Error,
+    helpers::{Direction, ReceivingEnd, Role},
+    secret_sharing::{
+        replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing},
+        SharedValue,
+    },
+};
+
+#[derive(Step)]
+pub(crate) enum OPRFShuffleStep {
+    ApplyPermutations,
+    GenerateAHat,
+    GenerateBHat,
+    GenerateZ,
+    TransferCHat,
+    TransferX2,
+    TransferY1,
+}
+
+/// # Errors
+/// Will propagate errors from transport and a few typecasts
+pub async fn shuffle<C, I, S>(ctx: C, shares: I) -> Result<Vec<AdditiveShare<S>>, Error>
+where
+    C: Context,
+    I: IntoIterator<Item = AdditiveShare<S>>,
+    I::IntoIter: ExactSizeIterator,
+    S: SharedValue + Add<Output = S>,
+    for<'a> &'a S: Add<S, Output = S>,
+    for<'a> &'a S: Add<&'a S, Output = S>,
+    Standard: Distribution<S>,
+{
+    // TODO: this code works with iterators and that costs it an extra allocation at the end.
+    // This protocol can take a mutable iterator and replace items in the input.
+    let shares = shares.into_iter();
+    let ctx_z = ctx.narrow(&OPRFShuffleStep::GenerateZ);
+    let zs = generate_random_tables_with_peers(shares.len(), &ctx_z);
+
+    match ctx.role() {
+        Role::H1 => run_h1(&ctx, shares.len(), shares, zs).await,
+        Role::H2 => run_h2(&ctx, shares.len(), shares, zs).await,
+        Role::H3 => run_h3(&ctx, shares.len(), zs).await,
+    }
+}
+
+async fn run_h1<C, I, S, Zl, Zr>(
+    ctx: &C,
+    batch_size: usize,
+    shares: I,
+    (z_31, z_12): (Zl, Zr),
+) -> Result<Vec<AdditiveShare<S>>, Error>
+where
+    C: Context,
+    I: IntoIterator<Item = AdditiveShare<S>>,
+    S: SharedValue + Add<Output = S>,
+    Zl: IntoIterator<Item = S>,
+    Zr: IntoIterator<Item = S>,
+    for<'a> &'a S: Add<Output = S>,
+    Standard: Distribution<S>,
+{
+    // 1. Generate helper-specific random tables
+    let ctx_a_hat = ctx.narrow(&OPRFShuffleStep::GenerateAHat);
+    let a_hat = generate_random_table_solo(batch_size, &ctx_a_hat, Direction::Left);
+
+    let ctx_b_hat = ctx.narrow(&OPRFShuffleStep::GenerateBHat);
+    let b_hat = generate_random_table_solo(batch_size, &ctx_b_hat, Direction::Right);
+
+    // 2. Run computations
+    let a_add_b_iter = shares
+        .into_iter()
+        .map(|s: AdditiveShare<S>| s.left().add(s.right()));
+    let mut x_1: Vec<S> = add_single_shares(a_add_b_iter, z_12).collect();
+
+    let ctx_perm = ctx.narrow(&OPRFShuffleStep::ApplyPermutations);
+    let (mut rng_perm_l, mut rng_perm_r) = ctx_perm.prss_rng();
+    x_1.shuffle(&mut rng_perm_r);
+
+    let mut x_2 = x_1;
+    add_single_shares_in_place(&mut x_2, z_31);
+    x_2.shuffle(&mut rng_perm_l);
+    send_to_peer(&x_2, ctx, &OPRFShuffleStep::TransferX2, Direction::Right).await?;
+
+    let res = combine_single_shares(a_hat, b_hat).collect::<Vec<_>>();
+    Ok(res)
+}
+
+async fn run_h2<C, I, S, Zl, Zr>(
+    ctx: &C,
+    batch_size: usize,
+    shares: I,
+    (z_12, z_23): (Zl, Zr),
+) -> Result<Vec<AdditiveShare<S>>, Error>
+where
+    C: Context,
+    I: IntoIterator<Item = AdditiveShare<S>>,
+    S: SharedValue + Add<Output = S>,
+    Zl: IntoIterator<Item = S>,
+    Zr: IntoIterator<Item = S>,
+    for<'a> &'a S: Add<S, Output = S>,
+    for<'a> &'a S: Add<&'a S, Output = S>,
+    Standard: Distribution<S>,
+{
+    // 1. Generate helper-specific random tables
+    let ctx_b_hat = ctx.narrow(&OPRFShuffleStep::GenerateBHat);
+    let b_hat: Vec<S> =
+        generate_random_table_solo(batch_size, &ctx_b_hat, Direction::Left).collect();
+
+    // 2. Run computations
+    let c = shares.into_iter().map(|s| s.right());
+    let mut y_1: Vec<S> = add_single_shares(c, z_12).collect();
+
+    let ctx_perm = ctx.narrow(&OPRFShuffleStep::ApplyPermutations);
+    let (mut rng_perm_l, mut rng_perm_r) = ctx_perm.prss_rng();
+    y_1.shuffle(&mut rng_perm_l);
+
+    let mut x_2: Vec<S> = Vec::with_capacity(batch_size);
+    future::try_join(
+        send_to_peer(&y_1, ctx, &OPRFShuffleStep::TransferY1, Direction::Right),
+        receive_from_peer_into(
+            &mut x_2,
+            batch_size,
+            ctx,
+            &OPRFShuffleStep::TransferX2,
+            Direction::Left,
+        ),
+    )
+    .await?;
+
+    let mut x_3 = x_2;
+    add_single_shares_in_place(&mut x_3, z_23);
+    x_3.shuffle(&mut rng_perm_r);
+
+    let mut c_hat_1 = repurpose_allocation(y_1);
+    c_hat_1.extend(add_single_shares(x_3.iter(), b_hat.iter()));
+
+    let mut c_hat_2 = repurpose_allocation(x_3);
+    future::try_join(
+        send_to_peer(
+            &c_hat_1,
+            ctx,
+            &OPRFShuffleStep::TransferCHat,
+            Direction::Right,
+        ),
+        receive_from_peer_into(
+            &mut c_hat_2,
+            batch_size,
+            ctx,
+            &OPRFShuffleStep::TransferCHat,
+            Direction::Right,
+        ),
+    )
+    .await?;
+
+    let c_hat = add_single_shares(c_hat_1.iter(), c_hat_2.iter());
+    let res = combine_single_shares(b_hat, c_hat).collect::<Vec<_>>();
+    Ok(res)
+}
+
+async fn run_h3<C, S, Zl, Zr>(
+    ctx: &C,
+    batch_size: usize,
+    (z_23, z_31): (Zl, Zr),
+) -> Result<Vec<AdditiveShare<S>>, Error>
+where
+    C: Context,
+    S: SharedValue + Add<Output = S>,
+    Zl: IntoIterator<Item = S>,
+    Zr: IntoIterator<Item = S>,
+    for<'a> &'a S: Add<&'a S, Output = S>,
+    Standard: Distribution<S>,
+{
+    // 1. Generate helper-specific random tables
+    let ctx_a_hat = ctx.narrow(&OPRFShuffleStep::GenerateAHat);
+    let a_hat: Vec<S> =
+        generate_random_table_solo(batch_size, &ctx_a_hat, Direction::Right).collect();
+
+    // 2. Run computations
+    let mut y_1 = Vec::<S>::with_capacity(batch_size);
+    receive_from_peer_into(
+        &mut y_1,
+        batch_size,
+        ctx,
+        &OPRFShuffleStep::TransferY1,
+        Direction::Left,
+    )
+    .await?;
+
+    let mut y_2 = y_1;
+    add_single_shares_in_place(&mut y_2, z_31);
+
+    let ctx_perm = ctx.narrow(&OPRFShuffleStep::ApplyPermutations);
+    let (mut rng_perm_l, mut rng_perm_r) = ctx_perm.prss_rng();
+    y_2.shuffle(&mut rng_perm_r);
+
+    let mut y_3 = y_2;
+    add_single_shares_in_place(&mut y_3, z_23);
+    y_3.shuffle(&mut rng_perm_l);
+
+    let c_hat_2: Vec<S> = add_single_shares(y_3.iter(), a_hat.iter()).collect();
+    let mut c_hat_1 = repurpose_allocation(y_3);
+    future::try_join(
+        send_to_peer(
+            &c_hat_2,
+            ctx,
+            &OPRFShuffleStep::TransferCHat,
+            Direction::Left,
+        ),
+        receive_from_peer_into(
+            &mut c_hat_1,
+            batch_size,
+            ctx,
+            &OPRFShuffleStep::TransferCHat,
+            Direction::Left,
+        ),
+    )
+    .await?;
+
+    let c_hat = add_single_shares(c_hat_1, c_hat_2);
+    let res = combine_single_shares(c_hat, a_hat).collect::<Vec<_>>();
+    Ok(res)
+}
+
+fn add_single_shares<A, B, S, L, R>(l: L, r: R) -> impl Iterator<Item = S>
+where
+    A: Add<B, Output = S>,
+    L: IntoIterator<Item = A>,
+    R: IntoIterator<Item = B>,
+{
+    l.into_iter().zip(r).map(|(a, b)| a + b)
+}
+
+fn add_single_shares_in_place<S, R>(items: &mut [S], r: R)
+where
+    S: AddAssign,
+    R: IntoIterator<Item = S>,
+{
+    items
+        .iter_mut()
+        .zip(r)
+        .for_each(|(item, rhs)| item.add_assign(rhs));
+}
+
+fn repurpose_allocation<S>(mut buf: Vec<S>) -> Vec<S> {
+    buf.clear();
+    buf
+}
+
+// --------------------------------------------------------------------------- //
+
+fn combine_single_shares<S, Il, Ir>(l: Il, r: Ir) -> impl Iterator<Item = AdditiveShare<S>>
+where
+    S: SharedValue,
+    Il: IntoIterator<Item = S>,
+    Ir: IntoIterator<Item = S>,
+{
+    l.into_iter()
+        .zip(r)
+        .map(|(li, ri)| AdditiveShare::new(li, ri))
+}
+
+fn generate_random_tables_with_peers<'a, C, S>(
+    batch_size: usize,
+    narrow_ctx: &'a C,
+) -> (impl Iterator<Item = S> + 'a, impl Iterator<Item = S> + 'a)
+where
+    C: Context,
+    Standard: Distribution<S>,
+    S: 'a,
+{
+    let (rng_l, rng_r) = narrow_ctx.prss_rng();
+    let with_left = rng_l.sample_iter(Standard).take(batch_size);
+    let with_right = rng_r.sample_iter(Standard).take(batch_size);
+    (with_left, with_right)
+}
+
+fn generate_random_table_solo<'a, C, S>(
+    batch_size: usize,
+    narrow_ctx: &'a C,
+    peer: Direction,
+) -> impl Iterator<Item = S> + 'a
+where
+    C: Context,
+    Standard: Distribution<S>,
+    S: 'a,
+{
+    let rngs = narrow_ctx.prss_rng();
+    let rng = match peer {
+        Direction::Left => rngs.0,
+        Direction::Right => rngs.1,
+    };
+
+    rng.sample_iter(Standard).take(batch_size)
+}
+
+// ---------------------------- helper communication ------------------------------------ //
+
+async fn send_to_peer<C, S>(
+    items: &[S],
+    ctx: &C,
+    step: &OPRFShuffleStep,
+    direction: Direction,
+) -> Result<(), Error>
+where
+    C: Context,
+    S: Copy + SharedValue,
+{
+    let role = ctx.role().peer(direction);
+    let send_channel = ctx
+        .narrow(step)
+        .set_total_records(items.len())
+        .send_channel(role);
+
+    for (record_id, row) in items.iter().enumerate() {
+        send_channel.send(RecordId::from(record_id), *row).await?;
+    }
+    Ok(())
+}
+
+async fn receive_from_peer_into<C, S>(
+    buf: &mut Vec<S>,
+    batch_size: usize,
+    ctx: &C,
+    step: &OPRFShuffleStep,
+    direction: Direction,
+) -> Result<(), Error>
+where
+    C: Context,
+    S: SharedValue,
+{
+    let role = ctx.role().peer(direction);
+    let receive_channel: ReceivingEnd<S> = ctx
+        .narrow(step)
+        .set_total_records(batch_size)
+        .recv_channel(role);
+
+    for record_id in 0..batch_size {
+        let msg = receive_channel.receive(RecordId::from(record_id)).await?;
+        buf.push(msg);
+    }
+    Ok(())
+}
+
+#[cfg(all(test, unit_test))]
+pub mod tests {
+    use super::shuffle;
+    use crate::{
+        ff::{Field, Gf40Bit},
+        test_fixture::{Reconstruct, Runner, TestWorld, TestWorldConfig},
+    };
+
+    pub type MatchKey = Gf40Bit;
+
+    #[tokio::test]
+    async fn shuffles_the_order() {
+        let mut i: u128 = 0;
+        let records = std::iter::from_fn(move || {
+            i += 1;
+            Some(MatchKey::truncate_from(i))
+        })
+        .take(100)
+        .collect::<Vec<_>>();
+
+        // Stable seed is used to get predictable shuffle results.
+        let mut actual = TestWorld::new_with(TestWorldConfig::default().with_seed(123))
+            .semi_honest(records.clone().into_iter(), |ctx, shares| async move {
+                shuffle(ctx, shares).await.unwrap()
+            })
+            .await
+            .reconstruct();
+
+        assert_ne!(
+            actual, records,
+            "Shuffle should produce a different order of items"
+        );
+
+        actual.sort();
+
+        assert_eq!(
+            actual, records,
+            "Shuffle should not change the items in the set"
+        );
+    }
+}
diff --git a/src/protocol/sort/apply_sort/mod.rs b/src/protocol/sort/apply_sort/mod.rs
index 10a783c09..131c0db46 100644
--- a/src/protocol/sort/apply_sort/mod.rs
+++ b/src/protocol/sort/apply_sort/mod.rs
@@ -5,12 +5,9 @@ pub use shuffle::shuffle_shares;
 use crate::{
     error::Error,
     protocol::{
-        basics::Reshare,
+        basics::{apply_permutation::apply_inv, Reshare},
         context::Context,
-        sort::{
-            apply::apply_inv, generate_permutation::RevealedAndRandomPermutations,
-            ApplyInvStep::ShuffleInputs,
-        },
+        sort::{generate_permutation::RevealedAndRandomPermutations, ApplyInvStep::ShuffleInputs},
         RecordId,
     },
 };
diff --git a/src/protocol/sort/apply_sort/shuffle.rs b/src/protocol/sort/apply_sort/shuffle.rs
index 9268e40dd..22a354cec 100644
--- a/src/protocol/sort/apply_sort/shuffle.rs
+++ b/src/protocol/sort/apply_sort/shuffle.rs
@@ -5,10 +5,12 @@ use crate::{
     error::Error,
     helpers::Direction,
     protocol::{
-        basics::Reshare,
+        basics::{
+            apply_permutation::{apply, apply_inv},
+            Reshare,
+        },
         context::Context,
         sort::{
-            apply::{apply, apply_inv},
             shuffle::{shuffle_for_helper, ShuffleOrUnshuffle},
             ShuffleStep::{self, Shuffle1, Shuffle2, Shuffle3},
         },
diff --git a/src/protocol/sort/compose.rs b/src/protocol/sort/compose.rs
index 2a858af55..0fe7f73d9 100644
--- a/src/protocol/sort/compose.rs
+++ b/src/protocol/sort/compose.rs
@@ -4,9 +4,9 @@ use crate::{
     error::Error,
     ff::Field,
     protocol::{
-        basics::Reshare,
+        basics::{apply_permutation::apply, Reshare},
         context::Context,
-        sort::{apply::apply, shuffle::unshuffle_shares, ComposeStep::UnshuffleRho},
+        sort::{shuffle::unshuffle_shares, ComposeStep::UnshuffleRho},
         RecordId,
     },
     secret_sharing::SecretSharing,
@@ -59,11 +59,9 @@ mod tests {
     use crate::{
         ff::{Field, Fp31},
         protocol::{
+            basics::apply_permutation::apply,
             context::{Context, SemiHonestContext, UpgradableContext, Validator},
-            sort::{
-                apply::apply, compose::compose,
-                generate_permutation::shuffle_and_reveal_permutation,
-            },
+            sort::{compose::compose, generate_permutation::shuffle_and_reveal_permutation},
         },
         rand::thread_rng,
         test_fixture::{Reconstruct, Runner, TestWorld},
diff --git a/src/protocol/sort/mod.rs b/src/protocol/sort/mod.rs
index 8427f0b03..c285af1b6 100644
--- a/src/protocol/sort/mod.rs
+++ b/src/protocol/sort/mod.rs
@@ -3,7 +3,6 @@ pub mod bit_permutation;
 pub mod generate_permutation;
 pub mod generate_permutation_opt;
 
-mod apply;
 mod compose;
 mod multi_bit_permutation;
 mod secureapplyinv;
diff --git a/src/protocol/sort/secureapplyinv.rs b/src/protocol/sort/secureapplyinv.rs
index 8cfb8aca9..ebced0c8f 100644
--- a/src/protocol/sort/secureapplyinv.rs
+++ b/src/protocol/sort/secureapplyinv.rs
@@ -1,12 +1,9 @@
 use crate::{
     error::Error,
     protocol::{
-        basics::Reshare,
+        basics::{apply_permutation::apply_inv, Reshare},
         context::Context,
-        sort::{
-            apply::apply_inv, apply_sort::shuffle_shares as shuffle_vectors,
-            ApplyInvStep::ShuffleInputs,
-        },
+        sort::{apply_sort::shuffle_shares as shuffle_vectors, ApplyInvStep::ShuffleInputs},
         RecordId,
     },
 };
@@ -38,9 +35,10 @@ mod tests {
         use crate::{
             ff::{Field, Fp31},
             protocol::{
+                basics::apply_permutation::apply_inv,
                 context::{Context, SemiHonestContext, UpgradableContext, Validator},
                 sort::{
-                    apply::apply_inv, generate_permutation::shuffle_and_reveal_permutation,
+                    generate_permutation::shuffle_and_reveal_permutation,
                     secureapplyinv::secureapplyinv_multi,
                 },
             },
diff --git a/src/protocol/sort/shuffle.rs b/src/protocol/sort/shuffle.rs
index feff12ee1..d500bf0a2 100644
--- a/src/protocol/sort/shuffle.rs
+++ b/src/protocol/sort/shuffle.rs
@@ -1,15 +1,20 @@
 use embed_doc_image::embed_doc_image;
 use rand::{seq::SliceRandom, Rng};
 
-use super::{
-    apply::{apply, apply_inv},
-    ShuffleStep::{self, Shuffle1, Shuffle2, Shuffle3},
-};
+use super::ShuffleStep::{self, Shuffle1, Shuffle2, Shuffle3};
 use crate::{
     error::Error,
     ff::Field,
     helpers::{Direction, Role},
-    protocol::{basics::Reshare, context::Context, step::Step, NoRecord, RecordId},
+    protocol::{
+        basics::{
+            apply_permutation::{apply, apply_inv},
+            Reshare,
+        },
+        context::Context,
+        step::Step,
+        NoRecord, RecordId,
+    },
     secret_sharing::SecretSharing,
 };
 
diff --git a/src/query/runner/mod.rs b/src/query/runner/mod.rs
index d9eb28f8f..3d1a3bebd 100644
--- a/src/query/runner/mod.rs
+++ b/src/query/runner/mod.rs
@@ -1,7 +1,6 @@
 mod aggregate;
 mod ipa;
 mod oprf_ipa;
-
 #[cfg(any(test, feature = "cli", feature = "test-fixture"))]
 mod test_multiply;
 
diff --git a/src/secret_sharing/replicated/semi_honest/additive_share.rs b/src/secret_sharing/replicated/semi_honest/additive_share.rs
index 0ae455ea9..5101c7182 100644
--- a/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -20,7 +20,6 @@ pub struct AdditiveShare<V: WeakSharedValue>(V, V);
 impl<V: WeakSharedValue> SecretSharing<V> for AdditiveShare<V> {
     const ZERO: Self = AdditiveShare::ZERO;
 }
-
 impl<V: SharedValue> LinearSecretSharing<V> for AdditiveShare<V> {}
 
 impl<V: WeakSharedValue + Debug> Debug for AdditiveShare<V> {

From 62e5139966d62393b45bc6c5086dc1961cecd126 Mon Sep 17 00:00:00 2001
From: Taiki Yamaguchi <taiki.yamaguchi@gmail.com>
Date: Wed, 8 Nov 2023 14:09:08 +0800
Subject: [PATCH 105/105] add more comments

---
 src/test_fixture/event_gen.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/test_fixture/event_gen.rs b/src/test_fixture/event_gen.rs
index 1ee75ef56..133745814 100644
--- a/src/test_fixture/event_gen.rs
+++ b/src/test_fixture/event_gen.rs
@@ -37,6 +37,8 @@ pub enum ReportFilter {
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "clap", derive(clap::Args))]
 pub struct Config {
+    /// Number of unique users per event generator. The generator will generate events
+    /// for at most this many users.
     #[cfg_attr(feature = "clap", arg(long, default_value = "1000000000000"))]
     pub user_count: NonZeroU64,
     #[cfg_attr(feature = "clap", arg(long, default_value = "5"))]
@@ -97,6 +99,8 @@ impl Config {
         }
     }
 
+    /// Returns the number of unique users per event generator. The generator will generate
+    /// events for at most this many users.
     fn user_count(&self) -> usize {
         usize::try_from(self.user_count.get()).unwrap()
     }