diff --git a/ipa-core/src/ff/boolean_array.rs b/ipa-core/src/ff/boolean_array.rs
index 8b421098b..1408660e4 100644
--- a/ipa-core/src/ff/boolean_array.rs
+++ b/ipa-core/src/ff/boolean_array.rs
@@ -215,8 +215,9 @@ macro_rules! impl_serializable_trait {
     };
 
     ($name: ident, $bits: tt, $store: ty, infallible) => {
-        const _SAFEGUARD: () = assert!(
-            $bits % 8 == 0,
+        $crate::const_assert_eq!(
+            $bits % 8,
+            0,
             "Infallible deserialization is defined for lengths that are multiples of 8 only"
         );
 
diff --git a/ipa-core/src/ff/curve_points.rs b/ipa-core/src/ff/curve_points.rs
index c5789e420..597673c97 100644
--- a/ipa-core/src/ff/curve_points.rs
+++ b/ipa-core/src/ff/curve_points.rs
@@ -8,6 +8,7 @@ use typenum::U32;
 use crate::{
     ff::{ec_prime_field::Fp25519, Serializable},
     impl_shared_value_common,
+    protocol::ipa_prf::PRF_CHUNK,
     secret_sharing::{Block, SharedValue, StdArray, Vectorizable},
 };
 
@@ -42,6 +43,10 @@ impl Vectorizable<1> for RP25519 {
     type Array = StdArray<Self, 1>;
 }
 
+impl Vectorizable<PRF_CHUNK> for RP25519 {
+    type Array = StdArray<Self, PRF_CHUNK>;
+}
+
 #[derive(thiserror::Error, Debug)]
 #[error("{0:?} is not the canonical encoding of a Ristretto point.")]
 pub struct NonCanonicalEncoding(CompressedRistretto);
diff --git a/ipa-core/src/ff/ec_prime_field.rs b/ipa-core/src/ff/ec_prime_field.rs
index dad5ca0f4..29d7964e0 100644
--- a/ipa-core/src/ff/ec_prime_field.rs
+++ b/ipa-core/src/ff/ec_prime_field.rs
@@ -5,10 +5,16 @@ use generic_array::GenericArray;
 use typenum::{U2, U32};
 
 use crate::{
-    ff::{boolean_array::BA256, Field, Serializable},
+    ff::{boolean_array::BA256, Expand, Field, Serializable},
     impl_shared_value_common,
-    protocol::prss::FromRandom,
-    secret_sharing::{Block, FieldVectorizable, SharedValue, StdArray, Vectorizable},
+    protocol::{
+        ipa_prf::PRF_CHUNK,
+        prss::{FromPrss, FromRandom, PrssIndex, SharedRandomness},
+    },
+    secret_sharing::{
+        replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing},
+        Block, FieldVectorizable, SharedValue, StdArray, Vectorizable,
+    },
 };
 
 impl Block for Scalar {
@@ -125,6 +131,20 @@ impl std::ops::MulAssign for Fp25519 {
     }
 }
 
+impl<const N: usize> Expand for AdditiveShare<Fp25519, N>
+where
+    Fp25519: Vectorizable<N>,
+{
+    type Input = AdditiveShare<Fp25519>;
+
+    fn expand(v: &Self::Input) -> Self {
+        AdditiveShare::new_arr(
+            <Fp25519 as Vectorizable<N>>::Array::expand(&v.left()),
+            <Fp25519 as Vectorizable<N>>::Array::expand(&v.right()),
+        )
+    }
+}
+
 impl From<Scalar> for Fp25519 {
     fn from(s: Scalar) -> Self {
         Fp25519(s)
@@ -185,6 +205,14 @@ impl FieldVectorizable<1> for Fp25519 {
     type ArrayAlias = StdArray<Self, 1>;
 }
 
+impl Vectorizable<PRF_CHUNK> for Fp25519 {
+    type Array = StdArray<Self, PRF_CHUNK>;
+}
+
+impl FieldVectorizable<PRF_CHUNK> for Fp25519 {
+    type ArrayAlias = StdArray<Self, PRF_CHUNK>;
+}
+
 impl Field for Fp25519 {
     const NAME: &'static str = "Fp25519";
 
@@ -203,6 +231,29 @@ impl FromRandom for Fp25519 {
     }
 }
 
+macro_rules! impl_share_from_random {
+    ($width:expr) => {
+        impl FromPrss for AdditiveShare<Fp25519, $width> {
+            fn from_prss_with<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(
+                prss: &P,
+                index: I,
+                _params: (),
+            ) -> AdditiveShare<Fp25519, $width> {
+                let (l_arr, r_arr) = StdArray::from_tuple_iter(
+                    prss.generate_chunks_iter::<_, U2>(index)
+                        .map(|(l_rand, r_rand)| {
+                            (Fp25519::from_random(l_rand), Fp25519::from_random(r_rand))
+                        })
+                        .take($width),
+                );
+                AdditiveShare::new_arr(l_arr, r_arr)
+            }
+        }
+    };
+}
+
+impl_share_from_random!(PRF_CHUNK);
+
 #[cfg(all(test, unit_test))]
 mod test {
     use curve25519_dalek::scalar::Scalar;
diff --git a/ipa-core/src/lib.rs b/ipa-core/src/lib.rs
index 784313c85..984ba0f12 100644
--- a/ipa-core/src/lib.rs
+++ b/ipa-core/src/lib.rs
@@ -145,6 +145,26 @@ pub(crate) mod test_executor {
     }
 }
 
+#[macro_export]
+macro_rules! const_assert {
+    ($x:expr $(,)?) => {
+        const _: () = assert!($x, stringify!($x));
+    };
+    ($x:expr, $msg:expr $(,)?) => {
+        const _: () = assert!($x, $msg);
+    };
+}
+
+#[macro_export]
+macro_rules! const_assert_eq {
+    ($x:expr, $y:expr $(,)?) => {
+        $crate::const_assert!($x == $y);
+    };
+    ($x:expr, $y:expr, $msg:expr $(,)?) => {
+        $crate::const_assert!($x == $y, $msg);
+    };
+}
+
 macro_rules! mutually_incompatible {
     ($feature1:literal,$feature2:literal) => {
         #[cfg(all(feature = $feature1, feature = $feature2))]
diff --git a/ipa-core/src/protocol/basics/mod.rs b/ipa-core/src/protocol/basics/mod.rs
index 7314af874..f7536d606 100644
--- a/ipa-core/src/protocol/basics/mod.rs
+++ b/ipa-core/src/protocol/basics/mod.rs
@@ -13,7 +13,7 @@ pub use check_zero::check_zero;
 pub use if_else::{if_else, select};
 pub use mul::{BooleanArrayMul, MultiplyZeroPositions, SecureMul, ZeroPositions};
 pub use reshare::Reshare;
-pub use reveal::{reveal, Reveal};
+pub use reveal::{partial_reveal, reveal, Reveal};
 pub use share_known_value::ShareKnownValue;
 pub use sum_of_product::SumOfProducts;
 
diff --git a/ipa-core/src/protocol/basics/reveal.rs b/ipa-core/src/protocol/basics/reveal.rs
index 4b9c21da5..42849ff6a 100644
--- a/ipa-core/src/protocol/basics/reveal.rs
+++ b/ipa-core/src/protocol/basics/reveal.rs
@@ -176,8 +176,9 @@ impl<'a, F: ExtendableField> Reveal<UpgradedMaliciousContext<'a, F>, 1> for Mali
     }
 }
 
-// Workaround for https://github.com/rust-lang/rust/issues/100013. Calling this wrapper function
-// instead of `Reveal::reveal` seems to hide the `impl Future` GAT.
+// Workaround for https://github.com/rust-lang/rust/issues/100013. Calling these wrapper functions
+// instead of the trait methods seems to hide the `impl Future` GAT.
+
 pub fn reveal<'fut, C, S>(
     ctx: C,
     record_id: RecordId,
@@ -190,6 +191,19 @@ where
     S::reveal(v, ctx, record_id)
 }
 
+pub fn partial_reveal<'fut, C, S, const N: usize>(
+    ctx: C,
+    record_id: RecordId,
+    excluded: Role,
+    v: &'fut S,
+) -> impl Future<Output = Result<Option<S::Output>, Error>> + Send + 'fut
+where
+    C: Context + 'fut,
+    S: Reveal<C, N>,
+{
+    S::partial_reveal(v, ctx, record_id, excluded)
+}
+
 #[cfg(all(test, unit_test))]
 mod tests {
     use std::iter::zip;
diff --git a/ipa-core/src/protocol/context/prss.rs b/ipa-core/src/protocol/context/prss.rs
index 5ff5d3cd2..cc1f7756c 100644
--- a/ipa-core/src/protocol/context/prss.rs
+++ b/ipa-core/src/protocol/context/prss.rs
@@ -1,6 +1,6 @@
 //! Metric-aware PRSS decorators
 
-use generic_array::{ArrayLength, GenericArray};
+use generic_array::ArrayLength;
 use rand_core::{Error, RngCore};
 
 use crate::{
@@ -35,16 +35,38 @@ impl<'a> InstrumentedIndexedSharedRandomness<'a> {
 }
 
 impl SharedRandomness for InstrumentedIndexedSharedRandomness<'_> {
-    fn generate_arrays<I: Into<PrssIndex>, N: ArrayLength>(
+    type ChunksIter<'a, Z: ArrayLength> = InstrumentedChunksIter<
+        'a,
+        <IndexedSharedRandomness as SharedRandomness>::ChunksIter<'a, Z>,
+    >
+    where Self: 'a;
+
+    fn generate_chunks_iter<I: Into<PrssIndex>, Z: ArrayLength>(
         &self,
         index: I,
-    ) -> (GenericArray<u128, N>, GenericArray<u128, N>) {
-        let step = self.step.as_ref().to_string();
+    ) -> Self::ChunksIter<'_, Z> {
+        InstrumentedChunksIter {
+            instrumented: self,
+            inner: self.inner.generate_chunks_iter(index),
+        }
+    }
+}
+
+pub struct InstrumentedChunksIter<'a, I: Iterator> {
+    instrumented: &'a InstrumentedIndexedSharedRandomness<'a>,
+    inner: I,
+}
+
+impl<'a, I: Iterator> Iterator for InstrumentedChunksIter<'a, I> {
+    type Item = <I as Iterator>::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let step = self.instrumented.step.as_ref().to_string();
         // TODO: what we really want here is a gauge indicating the maximum index used to generate
         // PRSS. Gauge infrastructure is not supported yet, `Metrics` struct needs to be able to
         // handle gauges
-        metrics::increment_counter!(INDEXED_PRSS_GENERATED, STEP => step, ROLE => self.role.as_static_str());
-        self.inner.generate_arrays(index)
+        metrics::increment_counter!(INDEXED_PRSS_GENERATED, STEP => step, ROLE => self.instrumented.role.as_static_str());
+        self.inner.next()
     }
 }
 
diff --git a/ipa-core/src/protocol/ipa_prf/boolean_ops/addition_sequential.rs b/ipa-core/src/protocol/ipa_prf/boolean_ops/addition_sequential.rs
index dc27e6ef7..b4dc09bce 100644
--- a/ipa-core/src/protocol/ipa_prf/boolean_ops/addition_sequential.rs
+++ b/ipa-core/src/protocol/ipa_prf/boolean_ops/addition_sequential.rs
@@ -1,13 +1,18 @@
+use std::{borrow::Borrow, iter::repeat, ops::Not};
+
 #[cfg(all(test, unit_test))]
 use ipa_macros::Step;
 
-#[cfg(all(test, unit_test))]
-use crate::secret_sharing::{FieldSimd, FieldVectorizable};
 use crate::{
     error::Error,
-    ff::{ArrayAccess, CustomArray, Field},
+    ff::{ArrayAccessRef, ArrayBuild, ArrayBuilder, Field},
     protocol::{basics::SecureMul, context::Context, step::BitOpStep, RecordId},
-    secret_sharing::{replicated::semi_honest::AdditiveShare, SharedValue},
+    secret_sharing::{replicated::semi_honest::AdditiveShare, FieldSimd},
+};
+#[cfg(all(test, unit_test))]
+use crate::{
+    ff::CustomArray,
+    secret_sharing::{FieldVectorizable, SharedValue},
 };
 
 #[cfg(all(test, unit_test))]
@@ -25,19 +30,20 @@ pub(crate) enum Step {
 ///
 /// # Errors
 /// propagates errors from multiply
-pub async fn integer_add<C, XS, YS>(
+pub async fn integer_add<C, F, XS, YS, const N: usize>(
     ctx: C,
     record_id: RecordId,
-    x: &AdditiveShare<XS>,
-    y: &AdditiveShare<YS>,
-) -> Result<(AdditiveShare<XS>, AdditiveShare<XS::Element>), Error>
+    x: &XS,
+    y: &YS,
+) -> Result<(XS, AdditiveShare<F, N>), Error>
 where
     C: Context,
-    YS: SharedValue + CustomArray<Element = XS::Element>,
-    XS: SharedValue + CustomArray,
-    XS::Element: Field,
+    F: Field + FieldSimd<N>,
+    XS: ArrayAccessRef<Element = AdditiveShare<F, N>> + ArrayBuild<Input = AdditiveShare<F, N>>,
+    YS: ArrayAccessRef<Element = AdditiveShare<F, N>>,
+    AdditiveShare<F, N>: SecureMul<C> + Not<Output = AdditiveShare<F, N>>,
 {
-    let mut carry = AdditiveShare::<XS::Element>::ZERO;
+    let mut carry = AdditiveShare::<F, N>::ZERO;
     let sum = addition_circuit(ctx, record_id, x, y, &mut carry).await?;
     Ok((sum, carry))
 }
@@ -59,6 +65,7 @@ where
     C: Context,
     S: SharedValue + CustomArray<Element = F>,
     AdditiveShare<S>: From<AdditiveShare<F, N>> + Into<AdditiveShare<F, N>>,
+    AdditiveShare<F>: Not<Output = AdditiveShare<F>>,
 {
     use crate::{ff::Expand, protocol::basics::if_else};
     let mut carry = AdditiveShare::<F>::ZERO;
@@ -95,35 +102,41 @@ where
 /// propagates errors from multiply
 ///
 ///
-async fn addition_circuit<C, XS, YS>(
+async fn addition_circuit<C, F, XS, YS, const N: usize>(
     ctx: C,
     record_id: RecordId,
-    x: &AdditiveShare<XS>,
-    y: &AdditiveShare<YS>,
-    carry: &mut AdditiveShare<XS::Element>,
-) -> Result<AdditiveShare<XS>, Error>
+    x: &XS,
+    y: &YS,
+    carry: &mut AdditiveShare<F, N>,
+) -> Result<XS, Error>
 where
     C: Context,
-    XS: SharedValue + CustomArray,
-    YS: SharedValue + CustomArray<Element = XS::Element>,
-    XS::Element: Field,
+    F: Field + FieldSimd<N>,
+    XS: ArrayAccessRef<Element = AdditiveShare<F, N>> + ArrayBuild<Input = AdditiveShare<F, N>>,
+    YS: ArrayAccessRef<Element = AdditiveShare<F, N>>,
+    AdditiveShare<F, N>: SecureMul<C> + Not<Output = AdditiveShare<F, N>>,
 {
-    let mut result = AdditiveShare::<XS>::ZERO;
-    for (i, v) in x.iter().enumerate() {
-        result.set(
-            i,
+    let x = x.iter();
+    let y = y.iter();
+
+    let mut result = XS::builder().with_capacity(x.len());
+    for (i, (xb, yb)) in x
+        .zip(y.chain(repeat(YS::make_ref(&AdditiveShare::<F, N>::ZERO))))
+        .enumerate()
+    {
+        result.push(
             bit_adder(
                 ctx.narrow(&BitOpStep::from(i)),
                 record_id,
-                &v,
-                y.get(i).as_ref(),
+                xb.borrow(),
+                yb.borrow(),
                 carry,
             )
             .await?,
         );
     }
 
-    Ok(result)
+    Ok(result.build())
 }
 
 ///
@@ -145,26 +158,23 @@ where
 ///
 /// # Errors
 /// propagates errors from multiply
-async fn bit_adder<C, S>(
+async fn bit_adder<C, F, const N: usize>(
     ctx: C,
     record_id: RecordId,
-    x: &AdditiveShare<S>,
-    y: Option<&AdditiveShare<S>>,
-    carry: &mut AdditiveShare<S>,
-) -> Result<AdditiveShare<S>, Error>
+    x: &AdditiveShare<F, N>,
+    y: &AdditiveShare<F, N>,
+    carry: &mut AdditiveShare<F, N>,
+) -> Result<AdditiveShare<F, N>, Error>
 where
     C: Context,
-    S: Field,
+    F: Field + FieldSimd<N>,
+    AdditiveShare<F, N>: SecureMul<C> + Not<Output = AdditiveShare<F, N>>,
 {
-    let output = x + y.unwrap_or(&AdditiveShare::<S>::ZERO) + &*carry;
+    let output = x + y + &*carry;
 
     *carry = &*carry
         + (x + &*carry)
-            .multiply(
-                &(y.unwrap_or(&AdditiveShare::<S>::ZERO) + &*carry),
-                ctx,
-                record_id,
-            )
+            .multiply(&(y + &*carry), ctx, record_id)
             .await?;
 
     Ok(output)
@@ -185,6 +195,7 @@ mod test {
             ipa_prf::boolean_ops::addition_sequential::{integer_add, integer_sat_add},
         },
         rand::thread_rng,
+        secret_sharing::replicated::semi_honest::AdditiveShare,
         test_executor::run,
         test_fixture::{Reconstruct, Runner, TestWorld},
     };
@@ -207,7 +218,7 @@ mod test {
 
             let (result, carry) = world
                 .semi_honest((x_ba64, y_ba64), |ctx, x_y| async move {
-                    integer_add::<_, BA64, BA64>(
+                    integer_add::<_, _, AdditiveShare<BA64>, AdditiveShare<BA64>, 1>(
                         ctx.set_total_records(1),
                         protocol::RecordId(0),
                         &x_y.0,
@@ -275,7 +286,7 @@ mod test {
 
             let (result, carry) = world
                 .semi_honest((x_ba64, y_ba32), |ctx, x_y| async move {
-                    integer_add::<_, BA64, BA32>(
+                    integer_add::<_, _, AdditiveShare<BA64>, AdditiveShare<BA32>, 1>(
                         ctx.set_total_records(1),
                         protocol::RecordId(0),
                         &x_y.0,
@@ -296,7 +307,7 @@ mod test {
             let expected_carry = (x + y) >> 32 & 1;
             let (result, carry) = world
                 .semi_honest((y_ba32, x_ba64), |ctx, x_y| async move {
-                    integer_add::<_, BA32, BA64>(
+                    integer_add::<_, _, AdditiveShare<BA32>, AdditiveShare<BA64>, 1>(
                         ctx.set_total_records(1),
                         protocol::RecordId(0),
                         &x_y.0,
diff --git a/ipa-core/src/protocol/ipa_prf/boolean_ops/comparison_and_subtraction_sequential.rs b/ipa-core/src/protocol/ipa_prf/boolean_ops/comparison_and_subtraction_sequential.rs
index 21b86aed5..cee540964 100644
--- a/ipa-core/src/protocol/ipa_prf/boolean_ops/comparison_and_subtraction_sequential.rs
+++ b/ipa-core/src/protocol/ipa_prf/boolean_ops/comparison_and_subtraction_sequential.rs
@@ -238,7 +238,6 @@ mod test {
     use std::{
         array,
         iter::{repeat, repeat_with, zip},
-        time::Instant,
     };
 
     use futures::stream::iter as stream_iter;
@@ -419,9 +418,10 @@ mod test {
 
             let result = world
                 .semi_honest((x.clone().into_iter(), y), |ctx, (x, y)| async move {
-                    let begin = Instant::now();
+                    #[cfg(not(debug_assertions))]
+                    let begin = std::time::Instant::now();
                     let ctx = ctx.set_total_records(x.len());
-                    let res = seq_join(
+                    let res: Vec<AdditiveShare<Boolean>> = seq_join(
                         ctx.active_work(),
                         stream_iter(x.into_iter().zip(repeat((ctx, y))).enumerate().map(
                             |(i, (x, (ctx, y)))| async move {
@@ -429,9 +429,10 @@ mod test {
                             },
                         )),
                     )
-                    .try_collect::<Vec<AdditiveShare<Boolean>>>()
+                    .try_collect()
                     .await
                     .unwrap();
+                    #[cfg(not(debug_assertions))]
                     tracing::info!("Execution time: {:?}", begin.elapsed());
                     res
                 })
@@ -494,10 +495,10 @@ mod test {
             let xa_iter = xa.clone().into_iter();
             let result = world
                 .semi_honest((xa_iter, ya.clone()), |ctx, (x, y)| async move {
-                    println!("Processing {} records", x.len());
-                    let begin = Instant::now();
+                    #[cfg(not(debug_assertions))]
+                    let begin = std::time::Instant::now();
                     let ctx = ctx.set_total_records(x.len());
-                    let res = seq_join(
+                    let res: Vec<AdditiveShare<Boolean, N>> = seq_join(
                         ctx.active_work(),
                         stream_iter(x.into_iter().zip(repeat((ctx, y))).enumerate().map(
                             |(i, (x, (ctx, y)))| async move {
@@ -505,9 +506,10 @@ mod test {
                             },
                         )),
                     )
-                    .try_collect::<Vec<AdditiveShare<Boolean, N>>>()
+                    .try_collect()
                     .await
                     .unwrap();
+                    #[cfg(not(debug_assertions))]
                     tracing::info!("Execution time: {:?}", begin.elapsed());
                     res
                 })
diff --git a/ipa-core/src/protocol/ipa_prf/boolean_ops/share_conversion_aby.rs b/ipa-core/src/protocol/ipa_prf/boolean_ops/share_conversion_aby.rs
index 8f8ae7ee2..b75660d4d 100644
--- a/ipa-core/src/protocol/ipa_prf/boolean_ops/share_conversion_aby.rs
+++ b/ipa-core/src/protocol/ipa_prf/boolean_ops/share_conversion_aby.rs
@@ -1,21 +1,28 @@
-use std::ops::Neg;
+use std::{
+    borrow::Borrow,
+    convert::Infallible,
+    ops::{Neg, Not},
+};
 
 use ipa_macros::Step;
 
 use crate::{
-    error::Error,
+    error::{Error, UnwrapInfallible},
     ff::{
-        boolean::Boolean, boolean_array::BA256, ec_prime_field::Fp25519, ArrayAccess, CustomArray,
-        Expand,
+        boolean::Boolean, boolean_array::BA256, ec_prime_field::Fp25519, ArrayAccess,
+        ArrayAccessRef, ArrayBuild, ArrayBuilder, CustomArray, Expand,
     },
     helpers::Role,
     protocol::{
-        basics::Reveal, context::Context, ipa_prf::boolean_ops::addition_sequential::integer_add,
-        prss::SharedRandomness, RecordId,
+        basics::{partial_reveal, Reveal, SecureMul},
+        context::Context,
+        ipa_prf::boolean_ops::addition_sequential::integer_add,
+        prss::{FromPrss, SharedRandomness},
+        RecordId,
     },
     secret_sharing::{
         replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing},
-        SharedValue,
+        FieldSimd, FieldVectorizable, SharedValue, SharedValueArray, TransposeFrom, Vectorizable,
     },
 };
 
@@ -24,7 +31,8 @@ pub(crate) enum Step {
     GenerateSecretSharing,
     IntegerAddBetweenMasks,
     IntegerAddMaskToX,
-    RevealY,
+    #[dynamic(256)]
+    RevealY(usize),
 }
 
 /// share conversion
@@ -90,56 +98,53 @@ pub(crate) enum Step {
 /// However, these terms are only non-zero when all `rs_{k}` terms are non-zero
 /// this happens with probability `1/(2^(256-m))` which is negligible for a sufficiently small `m`
 ///
+/// The implementation uses two type parameters to support vectorization. The type `XS` holds match
+/// keys. In the unvectorized case, `XS` is `AdditiveShare<BA64>`. In the vectorized case, `XS` is
+/// `BitDecomposed<AdditiveShare<BA{N}>>`. The type `YS` holds bitwise Fp25519 intermediates. In the
+/// unvectorized case, `YS` is `AdditiveShare<BA256>`. In the vectorized case, `YS` is
+/// `BitDecomposed<AdditiveShare<BA{n}>>`.
+///
 /// # Errors
 /// Propagates Errors from Integer Subtraction and Partial Reveal
-pub async fn convert_to_fp25519<C, B>(
+pub async fn convert_to_fp25519<C, XS, YS, const N: usize>(
     ctx: C,
     record_id: RecordId,
-    x: &AdditiveShare<B>,
-) -> Result<AdditiveShare<Fp25519>, Error>
+    x: XS,
+) -> Result<AdditiveShare<Fp25519, N>, Error>
 where
     C: Context,
-    B: SharedValue + CustomArray<Element = Boolean>,
+    Fp25519: Vectorizable<N>,
+    Boolean: FieldSimd<N>,
+    XS: ArrayAccessRef<Element = AdditiveShare<Boolean, N>>,
+    YS: ArrayAccessRef<Element = AdditiveShare<Boolean, N>>
+        + ArrayBuild<Input = AdditiveShare<Boolean, N>>
+        + FromPrss<usize>,
+    AdditiveShare<Boolean, N>: SecureMul<C>
+        + Reveal<C, N, Output = <Boolean as FieldVectorizable<N>>::ArrayAlias>
+        + Not<Output = AdditiveShare<Boolean, N>>,
+    Vec<AdditiveShare<BA256>>: for<'a> TransposeFrom<&'a YS>,
+    Vec<BA256>:
+        for<'a> TransposeFrom<&'a [<Boolean as Vectorizable<N>>::Array; 256], Error = Infallible>,
 {
+    // `BITS` is the number of bits in the memory representation of Fp25519 field elements. It does
+    // not vary with vectorization. Where the type `BA256` appears literally in the source of this
+    // function, it is referring to this constant. (It is also possible for `BA256` to be used to
+    // hold width-256 vectorizations, but when it serves that purpose, it does not appear literally
+    // in the source of this function -- it is behind the XS and YS parameters.)
+    const BITS: usize = 256;
+
+    // Ensure that the probability of leaking information is less than 1/(2^128).
+    debug_assert!(x.iter().count() < (BITS - 128));
+
     // generate sh_r = (0, 0, sh_r) and sh_s = (sh_s, 0, 0)
     // the two highest bits are set to 0 to allow carries for two additions
-    let (sh_r, sh_s) = {
-        // this closure generates sh_r, sh_r from PRSS randomness r
-
-        // we generate random values r = (r1,r2,r3) using PRSS
-        // r: H1: (r1,r2), H2: (r2,r3), H3: (r3, r1)
-        let mut r: AdditiveShare<BA256> = ctx
-            .narrow(&Step::GenerateSecretSharing)
-            .prss()
-            .generate(record_id);
-
-        // set 2 highest order bits of r1, r2, r3 to 0
-        r.set(255, AdditiveShare::<Boolean>::ZERO);
-        r.set(254, AdditiveShare::<Boolean>::ZERO);
-
-        // generate sh_r, sh_s
-        // sh_r: H1: (0,0), H2: (0,r3), H3: (r3, 0)
-        // sh_s: H1: (r1,0), H2: (0,0), H3: (0, r1)
-        match ctx.role() {
-            Role::H1 => (
-                AdditiveShare::new(<BA256 as SharedValue>::ZERO, <BA256 as SharedValue>::ZERO),
-                AdditiveShare::new(r.left(), <BA256 as SharedValue>::ZERO),
-            ),
-            Role::H2 => (
-                AdditiveShare::new(<BA256 as SharedValue>::ZERO, r.right()),
-                AdditiveShare::new(<BA256 as SharedValue>::ZERO, <BA256 as SharedValue>::ZERO),
-            ),
-            Role::H3 => (
-                AdditiveShare::new(r.left(), <BA256 as SharedValue>::ZERO),
-                AdditiveShare::new(<BA256 as SharedValue>::ZERO, r.right()),
-            ),
-        }
-    };
+    let (sh_r, sh_s) =
+        gen_sh_r_and_sh_s::<_, _, BITS, N>(&ctx.narrow(&Step::GenerateSecretSharing), record_id);
 
     // addition r+s might cause carry,
     // this is no problem since we have set bit 254 of sh_r and sh_s to 0
     let sh_rs = {
-        let (mut rs_with_higherorderbits, _) = integer_add::<_, BA256, BA256>(
+        let (mut rs_with_higherorderbits, _) = integer_add::<_, _, YS, YS, N>(
             ctx.narrow(&Step::IntegerAddBetweenMasks),
             record_id,
             &sh_r,
@@ -149,7 +154,7 @@ where
 
         // PRSS/Multiply masks added random highest order bit,
         // remove them to not cause overflow in second addition (which is mod 256):
-        rs_with_higherorderbits.set(255, AdditiveShare::<Boolean>::ZERO);
+        rs_with_higherorderbits.set(BITS - 1, YS::make_ref(&AdditiveShare::<Boolean, N>::ZERO));
 
         // return rs
         rs_with_higherorderbits
@@ -158,30 +163,127 @@ where
     // addition x+rs, where rs=r+s might cause carry
     // this is not a problem since bit 255 of rs is set to 0
     let (sh_y, _) =
-        integer_add::<_, BA256, B>(ctx.narrow(&Step::IntegerAddMaskToX), record_id, &sh_rs, x)
+        integer_add::<_, _, YS, XS, N>(ctx.narrow(&Step::IntegerAddMaskToX), record_id, &sh_rs, &x)
             .await?;
 
     // this leaks information, but with negligible probability
-    let y = AdditiveShare::<BA256>::new(sh_y.left(), sh_y.right())
-        .partial_reveal(ctx.narrow(&Step::RevealY), record_id, Role::H3)
+    let mut y = (ctx.role() != Role::H3).then(|| Vec::with_capacity(N));
+    for i in 0..BITS {
+        let y_bit = partial_reveal(
+            ctx.narrow(&Step::RevealY(i)),
+            record_id,
+            Role::H3,
+            sh_y.get(i).unwrap().borrow(),
+        )
         .await?;
+        match (&mut y, y_bit) {
+            (Some(y), Some(y_bit)) => y.push(y_bit),
+            (None, None) => (),
+            _ => unreachable!("inconsistent partial_reveal behavior"),
+        }
+    }
+
+    let y = y.map(|y| {
+        Vec::<BA256>::transposed_from(y.as_slice().try_into().unwrap()).unwrap_infallible()
+    });
+
+    let sh_r = Vec::<AdditiveShare<BA256>>::transposed_from(&sh_r)
+        .ok()
+        .expect("sh_r was constructed with the correct number of bits");
+    let sh_s = Vec::<AdditiveShare<BA256>>::transposed_from(&sh_s)
+        .ok()
+        .expect("sh_s was constructed with the correct number of bits");
 
     match ctx.role() {
-        Role::H1 => Ok(AdditiveShare::<Fp25519>::new(
-            Fp25519::from(sh_s.left()).neg(),
-            Fp25519::from(BA256::from_array(&y.unwrap())),
+        Role::H1 => Ok(AdditiveShare::<Fp25519, N>::new_arr(
+            <Fp25519 as Vectorizable<N>>::Array::from_fn(|i| {
+                Fp25519::from(sh_s.get(i).unwrap().left()).neg()
+            }),
+            y.unwrap().into_iter().map(Fp25519::from).collect(),
         )),
-        Role::H2 => Ok(AdditiveShare::<Fp25519>::new(
-            Fp25519::from(BA256::from_array(&y.unwrap())),
-            Fp25519::from(sh_r.right()).neg(),
+        Role::H2 => Ok(AdditiveShare::<Fp25519, N>::new_arr(
+            y.unwrap().into_iter().map(Fp25519::from).collect(),
+            <Fp25519 as Vectorizable<N>>::Array::from_fn(|i| {
+                Fp25519::from(sh_r.get(i).unwrap().right()).neg()
+            }),
         )),
-        Role::H3 => Ok(AdditiveShare::<Fp25519>::new(
-            Fp25519::from(sh_r.left()).neg(),
-            Fp25519::from(sh_s.right()).neg(),
+        Role::H3 => Ok(AdditiveShare::<Fp25519, N>::new_arr(
+            <Fp25519 as Vectorizable<N>>::Array::from_fn(|i| {
+                Fp25519::from(sh_r.get(i).unwrap().left()).neg()
+            }),
+            <Fp25519 as Vectorizable<N>>::Array::from_fn(|i| {
+                Fp25519::from(sh_s.get(i).unwrap().right()).neg()
+            }),
         )),
     }
 }
 
+/// Generates `sh_r` and `sh_s` from PRSS randomness (`r`).
+fn gen_sh_r_and_sh_s<C, YS, const BITS: usize, const N: usize>(
+    ctx: &C,
+    record_id: RecordId,
+) -> (YS, YS)
+where
+    C: Context,
+    Boolean: FieldSimd<N>,
+    YS: ArrayAccessRef<Element = AdditiveShare<Boolean, N>>
+        + ArrayBuild<Input = AdditiveShare<Boolean, N>>
+        + FromPrss<usize>,
+{
+    // we generate random values r = (r1,r2,r3) using PRSS
+    // r: H1: (r1,r2), H2: (r2,r3), H3: (r3, r1)
+    let mut r: YS = ctx.prss().generate_with(record_id, BITS);
+
+    // set 2 highest order bits of r1, r2, r3 to 0
+    r.set(BITS - 1, YS::make_ref(&AdditiveShare::<Boolean, N>::ZERO));
+    r.set(BITS - 2, YS::make_ref(&AdditiveShare::<Boolean, N>::ZERO));
+
+    let mut sh_r_builder = YS::builder().with_capacity(BITS);
+    let mut sh_s_builder = YS::builder().with_capacity(BITS);
+    // generate sh_r, sh_s
+    // sh_r: H1: (0,0), H2: (0,r3), H3: (r3, 0)
+    // sh_s: H1: (r1,0), H2: (0,0), H3: (0, r1)
+    match ctx.role() {
+        Role::H1 => {
+            for i in 0..BITS {
+                sh_r_builder.push(AdditiveShare::new_arr(
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                ));
+                sh_s_builder.push(AdditiveShare::new_arr(
+                    r.get(i).unwrap().borrow().left_arr().clone(),
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                ));
+            }
+        }
+        Role::H2 => {
+            for i in 0..BITS {
+                sh_r_builder.push(AdditiveShare::new_arr(
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                    r.get(i).unwrap().borrow().right_arr().clone(),
+                ));
+                sh_s_builder.push(AdditiveShare::new_arr(
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                ));
+            }
+        }
+        Role::H3 => {
+            for i in 0..BITS {
+                sh_r_builder.push(AdditiveShare::new_arr(
+                    r.get(i).unwrap().borrow().left_arr().clone(),
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                ));
+                sh_s_builder.push(AdditiveShare::new_arr(
+                    <Boolean as Vectorizable<N>>::Array::ZERO_ARRAY,
+                    r.get(i).unwrap().borrow().right_arr().clone(),
+                ));
+            }
+        }
+    }
+    (sh_r_builder.build(), sh_s_builder.build())
+}
+
 /// inserts smaller array in the larger array starting from location offset
 pub fn expand_shared_array_in_place<YS, XS>(
     y: &mut AdditiveShare<YS>,
@@ -192,9 +294,10 @@ pub fn expand_shared_array_in_place<YS, XS>(
     XS: SharedValue + ArrayAccess<Output = Boolean> + Expand<Input = Boolean>,
 {
     for i in 0..XS::BITS as usize {
-        y.set(
+        ArrayAccess::set(
+            y,
             i + offset,
-            x.get(i).unwrap_or(AdditiveShare::<Boolean>::ZERO),
+            ArrayAccess::get(x, i).unwrap_or(AdditiveShare::<Boolean>::ZERO),
         );
     }
 }
@@ -207,9 +310,10 @@ where
 {
     let mut x = AdditiveShare::<XS>::ZERO;
     for i in 0..XS::BITS as usize {
-        x.set(
+        ArrayAccess::set(
+            &mut x,
             i,
-            y.get(i + offset).unwrap_or(AdditiveShare::<Boolean>::ZERO),
+            ArrayAccess::get(y, i + offset).unwrap_or(AdditiveShare::<Boolean>::ZERO),
         );
     }
     x
@@ -238,60 +342,137 @@ where
 
 #[cfg(all(test, unit_test))]
 mod tests {
+    use std::iter::repeat_with;
+
     use curve25519_dalek::Scalar;
+    use futures::stream::TryStreamExt;
     use generic_array::GenericArray;
     use rand::Rng;
     use typenum::U32;
 
+    use super::*;
     use crate::{
-        ff::{
-            boolean::Boolean,
-            boolean_array::{BA256, BA64},
-            ec_prime_field::Fp25519,
-            ArrayAccess, Serializable,
-        },
-        protocol,
-        protocol::{
-            context::Context,
-            ipa_prf::boolean_ops::share_conversion_aby::{convert_to_fp25519, expand_array},
-        },
+        ff::{boolean_array::BA64, Serializable},
+        helpers::stream::{ProcessChunks, TryFlattenItersExt},
         rand::thread_rng,
-        secret_sharing::SharedValue,
+        seq_join::{seq_join, SeqJoin},
         test_executor::run,
-        test_fixture::{Reconstruct, Runner, TestWorld},
+        test_fixture::{ReconstructArr, Runner, TestWorld},
+        BoolVector,
     };
 
-    #[test]
-    fn semi_honest_convert_into_fp25519() {
+    fn test_semi_honest_convert_into_fp25519<XS, YS, const COUNT: usize, const CHUNK: usize>()
+    where
+        Fp25519: Vectorizable<CHUNK>,
+        Boolean: FieldSimd<CHUNK>,
+        XS: ArrayAccessRef<Element = AdditiveShare<Boolean, CHUNK>>
+            + ArrayBuild<Input = AdditiveShare<Boolean, CHUNK>>
+            + for<'a> TransposeFrom<&'a [AdditiveShare<BA64>; CHUNK], Error = Infallible>
+            + Send
+            + Sync
+            + 'static,
+        YS: ArrayAccessRef<Element = AdditiveShare<Boolean, CHUNK>>
+            + ArrayBuild<Input = AdditiveShare<Boolean, CHUNK>>
+            + FromPrss<usize>
+            + Send
+            + Sync
+            + 'static,
+        for<'a> <XS as ArrayAccessRef>::Ref<'a>: Send,
+        for<'a> <YS as ArrayAccessRef>::Ref<'a>: Send,
+        AdditiveShare<Boolean, CHUNK>: Not<Output = AdditiveShare<Boolean, CHUNK>>,
+        Vec<AdditiveShare<BA256>>: for<'a> TransposeFrom<&'a YS>,
+        Vec<BA256>: for<'a> TransposeFrom<
+            &'a [<Boolean as Vectorizable<CHUNK>>::Array; 256],
+            Error = Infallible,
+        >,
+        [AdditiveShare<Fp25519, CHUNK>; 3]: ReconstructArr<<Fp25519 as Vectorizable<CHUNK>>::Array>,
+    {
         run(|| async move {
             let world = TestWorld::default();
 
             let mut rng = thread_rng();
 
-            let records = rng.gen::<BA64>();
-
-            let mut buf: GenericArray<u8, U32> = [0u8; 32].into();
-
-            expand_array::<BA64, BA256>(&records, None).serialize(&mut buf);
+            let records = repeat_with(|| rng.gen::<BA64>())
+                .take(COUNT)
+                .collect::<Vec<_>>();
 
-            let expected = Fp25519::from(<Scalar>::from_bytes_mod_order(<[u8; 32]>::from(buf)));
+            let expected = records
+                .iter()
+                .map(|record| {
+                    let mut buf: GenericArray<u8, U32> = [0u8; 32].into();
+                    expand_array::<BA64, BA256>(record, None).serialize(&mut buf);
+                    Fp25519::from(<Scalar>::from_bytes_mod_order(<[u8; 32]>::from(buf)))
+                })
+                .collect::<Vec<_>>();
 
-            let result = world
-                .semi_honest(records, |ctx, x| async move {
-                    convert_to_fp25519::<_, BA64>(
-                        ctx.set_total_records(1),
-                        protocol::RecordId(0),
-                        &x,
+            let [res0, res1, res2] = world
+                .semi_honest(records.into_iter(), |ctx, records| async move {
+                    #[cfg(not(debug_assertions))]
+                    let begin = std::time::Instant::now();
+                    let res: Result<Vec<AdditiveShare<Fp25519>>, Error> = seq_join(
+                        ctx.active_work(),
+                        records.process_chunks(
+                            |idx, chunk| {
+                                let ctx = ctx.clone();
+                                async move {
+                                    let mut match_keys_builder = XS::builder();
+                                    for _ in 0..CHUNK {
+                                        match_keys_builder
+                                            .push(AdditiveShare::<Boolean, CHUNK>::ZERO);
+                                    }
+                                    let mut match_keys = match_keys_builder.build();
+                                    match_keys.transpose_from(&chunk).unwrap_infallible();
+                                    convert_to_fp25519::<_, XS, YS, CHUNK>(
+                                        ctx.set_total_records((COUNT + CHUNK - 1) / CHUNK),
+                                        RecordId::from(idx),
+                                        match_keys,
+                                    )
+                                    .await
+                                    .map(|shares| {
+                                        shares
+                                            .into_unpacking_iter()
+                                            .collect::<Vec<_>>()
+                                            .try_into()
+                                            .unwrap()
+                                    })
+                                }
+                            },
+                            || AdditiveShare::<BA64>::ZERO,
+                        ),
                     )
-                    .await
-                    .unwrap()
+                    .try_flatten_iters()
+                    .try_collect()
+                    .await;
+                    #[cfg(not(debug_assertions))]
+                    tracing::info!("Execution time: {:?}", begin.elapsed());
+                    res
                 })
                 .await
-                .reconstruct();
+                .map(Result::unwrap);
+            let mut result = Vec::with_capacity(COUNT);
+            for line in res0.into_iter().zip(res1).zip(res2) {
+                let ((s0, s1), s2) = line;
+                result.extend([s0, s1, s2].reconstruct_arr().into_iter());
+            }
             assert_eq!(result, expected);
         });
     }
 
+    // The third generic parameter in these calls is the number of conversions. It is set to give
+    // reasonable runtime for debug builds. These can also be used for benchmarking, in which case
+    // a size of 4096 is reasonable.
+
+    #[test]
+    fn semi_honest_convert_into_fp25519_novec() {
+        test_semi_honest_convert_into_fp25519::<BoolVector!(64, 1), BoolVector!(256, 1), 2, 1>();
+    }
+
+    #[test]
+    fn semi_honest_convert_into_fp25519_vec64() {
+        test_semi_honest_convert_into_fp25519::<BoolVector!(64, 64), BoolVector!(256, 64), 65, 64>(
+        );
+    }
+
     #[test]
     fn test_expand() {
         let mut rng = thread_rng();
diff --git a/ipa-core/src/protocol/ipa_prf/mod.rs b/ipa-core/src/protocol/ipa_prf/mod.rs
index aab014b52..aa5628c70 100644
--- a/ipa-core/src/protocol/ipa_prf/mod.rs
+++ b/ipa-core/src/protocol/ipa_prf/mod.rs
@@ -1,5 +1,6 @@
-use std::{num::NonZeroU32, ops::Add};
+use std::{array, iter, num::NonZeroU32, ops::Add};
 
+use futures_util::TryStreamExt;
 use generic_array::{ArrayLength, GenericArray};
 use ipa_macros::Step;
 use typenum::{Unsigned, U18};
@@ -11,6 +12,7 @@ use crate::{
         boolean::Boolean, boolean_array::BA64, CustomArray, PrimeField, Serializable,
         U128Conversions,
     },
+    helpers::stream::{ChunkData, ProcessChunks, TryFlattenItersExt},
     protocol::{
         basics::BooleanArrayMul,
         context::{UpgradableContext, UpgradedContext},
@@ -25,8 +27,10 @@ use crate::{
     },
     secret_sharing::{
         replicated::{malicious::ExtendableField, semi_honest::AdditiveShare as Replicated},
-        SharedValue,
+        SharedValue, TransposeFrom,
     },
+    seq_join::seq_join,
+    BoolVector,
 };
 
 mod boolean_ops;
@@ -38,6 +42,12 @@ mod malicious_security;
 mod quicksort;
 mod shuffle;
 
+/// Match key size
+pub const MK_BITS: usize = 64;
+
+/// Vectorization dimension for PRF
+pub const PRF_CHUNK: usize = 64;
+
 #[derive(Step)]
 pub(crate) enum Step {
     ConvertFp25519,
@@ -47,8 +57,8 @@ pub(crate) enum Step {
     SortByTimestamp,
 }
 
-#[derive(Debug)]
-#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
+#[derive(Clone, Debug)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct OPRFIPAInputRow<BK: SharedValue, TV: SharedValue, TS: SharedValue> {
     pub match_key: Replicated<BA64>,
     pub is_trigger: Replicated<Boolean>,
@@ -186,7 +196,7 @@ where
 {
     let shuffled = shuffle_inputs(ctx.narrow(&Step::Shuffle), input_rows).await?;
     let mut prfd_inputs =
-        compute_prf_for_inputs(ctx.narrow(&Step::ConvertInputRowsToPrf), shuffled).await?;
+        compute_prf_for_inputs(ctx.narrow(&Step::ConvertInputRowsToPrf), &shuffled).await?;
 
     prfd_inputs.sort_by(|a, b| a.prf_of_match_key.cmp(&b.prf_of_match_key));
 
@@ -212,7 +222,7 @@ where
 #[tracing::instrument(name = "compute_prf_for_inputs", skip_all)]
 async fn compute_prf_for_inputs<C, BK, TV, TS, F>(
     ctx: C,
-    input_rows: Vec<OPRFIPAInputRow<BK, TV, TS>>,
+    input_rows: &[OPRFIPAInputRow<BK, TV, TS>],
 ) -> Result<Vec<PrfShardedIpaInputRow<BK, TV, TS>>, Error>
 where
     C: UpgradableContext,
@@ -224,35 +234,74 @@ where
     F: PrimeField + ExtendableField,
     Replicated<F>: Serializable,
 {
-    let ctx = ctx.set_total_records(input_rows.len());
+    let ctx = ctx.set_total_records((input_rows.len() + PRF_CHUNK - 1) / PRF_CHUNK);
     let convert_ctx = ctx.narrow(&Step::ConvertFp25519);
     let eval_ctx = ctx.narrow(&Step::EvalPrf);
 
     let prf_key = gen_prf_key(&convert_ctx);
 
-    ctx.try_join(input_rows.into_iter().enumerate().map(|(idx, record)| {
-        let convert_ctx = convert_ctx.clone();
-        let eval_ctx = eval_ctx.clone();
-        let prf_key = &prf_key;
-        async move {
-            let record_id = RecordId::from(idx);
-            let elliptic_curve_pt =
-                convert_to_fp25519::<_, BA64>(convert_ctx, record_id, &record.match_key).await?;
-            let elliptic_curve_pt =
-                eval_dy_prf(eval_ctx, record_id, prf_key, &elliptic_curve_pt).await?;
-
-            Ok::<_, Error>(PrfShardedIpaInputRow {
-                prf_of_match_key: elliptic_curve_pt,
-                is_trigger_bit: record.is_trigger,
-                breakdown_key: record.breakdown_key,
-                trigger_value: record.trigger_value,
-                timestamp: record.timestamp,
-                sort_key: Replicated::ZERO,
-            })
-        }
-    }))
+    seq_join(
+        ctx.active_work(),
+        input_rows.process_chunks(
+            move |idx, records: ChunkData<_, PRF_CHUNK>| {
+                let convert_ctx = convert_ctx.clone();
+                let eval_ctx = eval_ctx.clone();
+                let prf_key = prf_key.clone();
+
+                async move {
+                    let record_id = RecordId::from(idx);
+                    let input_match_keys: &dyn Fn(usize) -> Replicated<BA64> =
+                        &|i| records[i].match_key.clone();
+                    let mut match_keys = iter::empty().collect::<BoolVector!(64, PRF_CHUNK)>();
+                    match_keys
+                        .transpose_from(input_match_keys)
+                        .unwrap_infallible();
+                    let curve_pts = convert_to_fp25519::<
+                        _,
+                        BoolVector!(64, PRF_CHUNK),
+                        BoolVector!(256, PRF_CHUNK),
+                        PRF_CHUNK,
+                    >(convert_ctx, record_id, match_keys)
+                    .await?;
+
+                    let prf_of_match_keys =
+                        eval_dy_prf::<_, PRF_CHUNK>(eval_ctx, record_id, &prf_key, curve_pts)
+                            .await?;
+
+                    Ok(array::from_fn(|i| {
+                        let OPRFIPAInputRow {
+                            match_key: _,
+                            is_trigger,
+                            breakdown_key,
+                            trigger_value,
+                            timestamp,
+                        } = &records[i];
+
+                        PrfShardedIpaInputRow {
+                            prf_of_match_key: prf_of_match_keys[i],
+                            is_trigger_bit: is_trigger.clone(),
+                            breakdown_key: breakdown_key.clone(),
+                            trigger_value: trigger_value.clone(),
+                            timestamp: timestamp.clone(),
+                            sort_key: Replicated::ZERO,
+                        }
+                    }))
+                }
+            },
+            || OPRFIPAInputRow {
+                match_key: Replicated::<BA64>::ZERO,
+                is_trigger: Replicated::<Boolean>::ZERO,
+                breakdown_key: Replicated::<BK>::ZERO,
+                trigger_value: Replicated::<TV>::ZERO,
+                timestamp: Replicated::<TS>::ZERO,
+            },
+        ),
+    )
+    .try_flatten_iters()
+    .try_collect()
     .await
 }
+
 #[cfg(all(test, any(unit_test, feature = "shuttle")))]
 pub mod tests {
     use crate::{
diff --git a/ipa-core/src/protocol/ipa_prf/prf_eval.rs b/ipa-core/src/protocol/ipa_prf/prf_eval.rs
index 10bbad630..a10a9a0e2 100644
--- a/ipa-core/src/protocol/ipa_prf/prf_eval.rs
+++ b/ipa-core/src/protocol/ipa_prf/prf_eval.rs
@@ -1,17 +1,19 @@
+use std::iter::zip;
+
 use ipa_macros::Step;
 
 use crate::{
     error::Error,
-    ff::{curve_points::RP25519, ec_prime_field::Fp25519},
+    ff::{boolean::Boolean, curve_points::RP25519, ec_prime_field::Fp25519, Expand},
     protocol::{
         basics::{Reveal, SecureMul},
         context::Context,
-        prss::SharedRandomness,
+        prss::{FromPrss, SharedRandomness},
         RecordId,
     },
     secret_sharing::{
-        replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing},
-        SharedValue,
+        replicated::semi_honest::AdditiveShare, FieldSimd, FieldVectorizable, Sendable, StdArray,
+        Vectorizable,
     },
 };
 
@@ -40,15 +42,25 @@ where
 {
     let ctx = sh_ctx.set_total_records(input_match_keys.len());
     let futures = input_match_keys
-        .iter()
+        .into_iter()
         .enumerate()
         .map(|(i, x)| eval_dy_prf(ctx.clone(), i.into(), &prf_key, x));
-    ctx.try_join(futures).await
+    Ok(ctx.try_join(futures).await?.into_iter().flatten().collect())
 }
 
-impl From<AdditiveShare<Fp25519>> for AdditiveShare<RP25519> {
-    fn from(s: AdditiveShare<Fp25519>) -> Self {
-        AdditiveShare::new(RP25519::from(s.left()), RP25519::from(s.right()))
+impl<const N: usize> From<AdditiveShare<Fp25519, N>> for AdditiveShare<RP25519, N>
+where
+    Fp25519: Vectorizable<N>,
+    RP25519: Vectorizable<N, Array = StdArray<RP25519, N>>,
+    StdArray<RP25519, N>: Sendable,
+{
+    fn from(value: AdditiveShare<Fp25519, N>) -> Self {
+        let (left_arr, right_arr) =
+            StdArray::<RP25519, N>::from_tuple_iter(value.into_unpacking_iter().map(|sh| {
+                let (l, r) = sh.as_tuple();
+                (RP25519::from(l), RP25519::from(r))
+            }));
+        Self::new_arr(left_arr, right_arr)
     }
 }
 
@@ -67,35 +79,47 @@ where
 /// 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>(
+/// # Panics
+/// Never as of when this comment was written, but the compiler didn't know that.
+pub async fn eval_dy_prf<C, const N: usize>(
     ctx: C,
     record_id: RecordId,
     k: &AdditiveShare<Fp25519>,
-    x: &AdditiveShare<Fp25519>,
-) -> Result<u64, Error>
+    x: AdditiveShare<Fp25519, N>,
+) -> Result<[u64; N], Error>
 where
     C: Context,
+    Fp25519: Vectorizable<N>,
+    RP25519: Vectorizable<N, Array = StdArray<RP25519, N>>,
+    Boolean: FieldSimd<N>,
+    AdditiveShare<Boolean, N>: Reveal<C, N, Output = <Boolean as FieldVectorizable<N>>::ArrayAlias>,
+    AdditiveShare<Fp25519, N>: SecureMul<C> + FromPrss,
+    StdArray<RP25519, N>: Sendable,
 {
-    let sh_r: AdditiveShare<Fp25519> = ctx.narrow(&Step::GenRandomMask).prss().generate(record_id);
-
-    //compute (g^left, g^right)
-    let sh_gr = AdditiveShare::<RP25519>::from(sh_r.clone());
+    let sh_r: AdditiveShare<Fp25519, N> =
+        ctx.narrow(&Step::GenRandomMask).prss().generate(record_id);
 
     //compute x+k
-    let mut y = x + k;
+    let mut y = x + AdditiveShare::<Fp25519, N>::expand(k);
 
     //compute y <- r*y
     y = y
         .multiply(&sh_r, ctx.narrow(&Step::MultMaskWithPRFInput), record_id)
         .await?;
 
+    //compute (g^left, g^right)
+    let sh_gr = AdditiveShare::<RP25519, N>::from(sh_r);
+
     //reconstruct (z,R)
-    let gr = RP25519::from_array(&sh_gr.reveal(ctx.narrow(&Step::RevealR), record_id).await?);
-    let z = Fp25519::from_array(&y.reveal(ctx.narrow(&Step::Revealz), record_id).await?);
+    let gr = 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())))
+    Ok(zip(gr, z)
+        .map(|(gr, z)| u64::from(gr * z.invert()))
+        .collect::<Vec<_>>()
+        .try_into()
+        .expect("iteration over arrays"))
 }
 
 #[cfg(all(test, unit_test))]
diff --git a/ipa-core/src/protocol/prss/crypto.rs b/ipa-core/src/protocol/prss/crypto.rs
index a332b9bea..0fa8c9209 100644
--- a/ipa-core/src/protocol/prss/crypto.rs
+++ b/ipa-core/src/protocol/prss/crypto.rs
@@ -13,7 +13,7 @@ use crate::{
     ff::Field,
     protocol::prss::PrssIndex,
     secret_sharing::{
-        replicated::{semi_honest::AdditiveShare as Replicated, ReplicatedSecretSharing},
+        replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing},
         SharedValue,
     },
 };
@@ -69,14 +69,30 @@ impl<T: FromRandomU128> FromRandom for T {
 ///
 /// In the first case, `FromPrss` is implemented for a tuple type, while in the second case,
 /// `FromPrss` is implemented for a secret-shared type.
-pub trait FromPrss: Sized {
-    fn from_prss<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(prss: &P, index: I) -> Self;
+pub trait FromPrss<Params = ()>
+where
+    Self: Sized,
+    Params: Default,
+{
+    fn from_prss_with<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(
+        prss: &P,
+        index: I,
+        params: Params,
+    ) -> Self;
+
+    fn from_prss<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(prss: &P, index: I) -> Self {
+        Self::from_prss_with(prss, index, Default::default())
+    }
 }
 
 /// Generate two random values, one that is known to the left helper
 /// and one that is known to the right helper.
 impl<T: FromRandom> FromPrss for (T, T) {
-    fn from_prss<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(prss: &P, index: I) -> (T, T) {
+    fn from_prss_with<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(
+        prss: &P,
+        index: I,
+        _params: (),
+    ) -> (T, T) {
         let (l, r) = prss.generate_arrays(index);
         (T::from_random(l), T::from_random(r))
     }
@@ -88,24 +104,68 @@ impl<T: FromRandom> FromPrss for (T, T) {
 /// "Efficient Bit-Decomposition and Modulus Conversion Protocols with an Honest Majority"
 /// by Ryo Kikuchi, Dai Ikarashi, Takahiro Matsuda, Koki Hamada, and Koji Chida
 /// <https://eprint.iacr.org/2018/387.pdf>
-impl<T: FromRandom + SharedValue> FromPrss for Replicated<T> {
-    fn from_prss<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(
+impl<T: FromRandom + SharedValue> FromPrss for AdditiveShare<T> {
+    fn from_prss_with<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(
         prss: &P,
         index: I,
-    ) -> Replicated<T> {
+        _params: (),
+    ) -> AdditiveShare<T> {
         let (l, r) = <(T, T) as FromPrss>::from_prss(prss, index);
-        Replicated::new(l, r)
+        AdditiveShare::new(l, r)
+    }
+}
+
+/// Generate a replicated secret sharing of a random value, which none
+/// of the helpers knows. This is an implementation of the functionality 2.1 `F_rand`
+/// described on page 5 of the paper:
+/// "Efficient Bit-Decomposition and Modulus Conversion Protocols with an Honest Majority"
+/// by Ryo Kikuchi, Dai Ikarashi, Takahiro Matsuda, Koki Hamada, and Koji Chida
+/// <https://eprint.iacr.org/2018/387.pdf>
+impl<T: FromRandom + SharedValue> FromPrss<usize> for AdditiveShare<T> {
+    fn from_prss_with<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(
+        prss: &P,
+        index: I,
+        len: usize,
+    ) -> AdditiveShare<T> {
+        assert_eq!(
+            u32::try_from(len).unwrap(),
+            <T as SharedValue>::BITS,
+            "incorrect length {len} for AdditiveShare::FromPrss, expected {}",
+            <T as SharedValue>::BITS,
+        );
+        let (l, r) = <(T, T) as FromPrss>::from_prss(prss, index);
+        AdditiveShare::new(l, r)
     }
 }
 
 pub trait SharedRandomness {
+    type ChunksIter<'a, Z: ArrayLength>: Iterator<
+        Item = (GenericArray<u128, Z>, GenericArray<u128, Z>),
+    >
+    where
+        Self: 'a;
+
+    /// Return an iterator over chunks of generated randomness.
+    ///
+    /// The iterator returns 2-tuples of `GenericArray<u128, Z>` chunks, one that is known to the
+    /// left helper and one that is known to the right helper.
+    ///
+    /// This functionality is intended for use generating large vectorized values.
+    #[must_use]
+    fn generate_chunks_iter<I: Into<PrssIndex>, Z: ArrayLength>(
+        &self,
+        index: I,
+    ) -> Self::ChunksIter<'_, Z>;
+
     /// Generate two random values, one that is known to the left helper
     /// and one that is known to the right helper.
     #[must_use]
     fn generate_arrays<I: Into<PrssIndex>, N: ArrayLength>(
         &self,
         index: I,
-    ) -> (GenericArray<u128, N>, GenericArray<u128, N>);
+    ) -> (GenericArray<u128, N>, GenericArray<u128, N>) {
+        Self::generate_chunks_iter(self, index).next().unwrap()
+    }
 
     /// Generate two random values, one that is known to the left helper
     /// and one that is known to the right helper.
@@ -133,6 +193,18 @@ pub trait SharedRandomness {
         T::from_prss(self, index)
     }
 
+    /// Generate something that implements the `FromPrss` trait, passing parameters.
+    ///
+    /// Generation by `FromPrss` is described in more detail in the `FromPrss` documentation.
+    #[must_use]
+    fn generate_with<T: FromPrss<P>, I: Into<PrssIndex>, P: Default>(
+        &self,
+        index: I,
+        params: P,
+    ) -> T {
+        T::from_prss_with(self, index, params)
+    }
+
     /// Generate a non-replicated additive secret sharing of zero.
     ///
     /// This is used for the MAC accumulators for malicious security.
diff --git a/ipa-core/src/protocol/prss/mod.rs b/ipa-core/src/protocol/prss/mod.rs
index 15690fd7e..41db1e7d3 100644
--- a/ipa-core/src/protocol/prss/mod.rs
+++ b/ipa-core/src/protocol/prss/mod.rs
@@ -4,6 +4,7 @@ use std::collections::HashSet;
 use std::{
     collections::HashMap,
     fmt::{Debug, Display, Formatter},
+    marker::PhantomData,
 };
 
 pub use crypto::{
@@ -157,20 +158,50 @@ pub struct IndexedSharedRandomness {
 }
 
 impl SharedRandomness for IndexedSharedRandomness {
-    fn generate_arrays<I: Into<PrssIndex>, N: ArrayLength>(
+    type ChunksIter<'a, Z: ArrayLength> = ChunksIter<'a, Z>;
+
+    fn generate_chunks_iter<I: Into<PrssIndex>, Z: ArrayLength>(
         &self,
         index: I,
-    ) -> (GenericArray<u128, N>, GenericArray<u128, N>) {
-        let index = index.into();
+    ) -> Self::ChunksIter<'_, Z> {
+        ChunksIter {
+            inner: self,
+            index: index.into(),
+            offset: 0,
+            phantom_data: PhantomData,
+        }
+    }
+}
+
+pub struct ChunksIter<'a, Z: ArrayLength> {
+    inner: &'a IndexedSharedRandomness,
+    index: PrssIndex,
+    offset: usize,
+    phantom_data: PhantomData<Z>,
+}
+
+impl<'a, Z: ArrayLength> Iterator for ChunksIter<'a, Z> {
+    type Item = (GenericArray<u128, Z>, GenericArray<u128, Z>);
+
+    fn next(&mut self) -> Option<Self::Item> {
         #[cfg(debug_assertions)]
         {
-            for i in 0..N::USIZE {
-                self.used.insert(index.offset(i));
+            for i in self.offset..self.offset + Z::USIZE {
+                self.inner.used.insert(self.index.offset(i));
             }
         }
-        let l = GenericArray::generate(|i| self.left.generate(index.offset(i).into()));
-        let r = GenericArray::generate(|i| self.right.generate(index.offset(i).into()));
-        (l, r)
+        let l = GenericArray::generate(|i| {
+            self.inner
+                .left
+                .generate(self.index.offset(self.offset + i).into())
+        });
+        let r = GenericArray::generate(|i| {
+            self.inner
+                .right
+                .generate(self.index.offset(self.offset + i).into())
+        });
+        self.offset += Z::USIZE;
+        Some((l, r))
     }
 }
 
diff --git a/ipa-core/src/protocol/step/steps.txt b/ipa-core/src/protocol/step/steps.txt
index 8bffb0fb6..5d233d7ef 100644
--- a/ipa-core/src/protocol/step/steps.txt
+++ b/ipa-core/src/protocol/step/steps.txt
@@ -515,7 +515,262 @@ ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol:
 ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::integer_add_mask_to_x/ipa_core::protocol::step::BitOpStep::bit97
 ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::integer_add_mask_to_x/ipa_core::protocol::step::BitOpStep::bit98
 ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::integer_add_mask_to_x/ipa_core::protocol::step::BitOpStep::bit99
-ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y0
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y1
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y10
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y100
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y101
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y102
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y103
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y104
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y105
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y106
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y107
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y108
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y109
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y11
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y110
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y111
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y112
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y113
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y114
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y115
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y116
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y117
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y118
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y119
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y12
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y120
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y121
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y122
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y123
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y124
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y125
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y126
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y127
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y128
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y129
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y13
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y130
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y131
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y132
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y133
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y134
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y135
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y136
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y137
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y138
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y139
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y14
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y140
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y141
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y142
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y143
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y144
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y145
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y146
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y147
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y148
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y149
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y15
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y150
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y151
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y152
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y153
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y154
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y155
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y156
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y157
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y158
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y159
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y16
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y160
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y161
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y162
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y163
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y164
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y165
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y166
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y167
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y168
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y169
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y17
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y170
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y171
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y172
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y173
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y174
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y175
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y176
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y177
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y178
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y179
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y18
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y180
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y181
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y182
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y183
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y184
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y185
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y186
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y187
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y188
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y189
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y19
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y190
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y191
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y192
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y193
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y194
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y195
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y196
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y197
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y198
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y199
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y2
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y20
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y200
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y201
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y202
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y203
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y204
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y205
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y206
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y207
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y208
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y209
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y21
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y210
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y211
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y212
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y213
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y214
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y215
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y216
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y217
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y218
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y219
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y22
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y220
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y221
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y222
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y223
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y224
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y225
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y226
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y227
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y228
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y229
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y23
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y230
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y231
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y232
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y233
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y234
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y235
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y236
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y237
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y238
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y239
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y24
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y240
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y241
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y242
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y243
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y244
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y245
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y246
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y247
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y248
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y249
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y25
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y250
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y251
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y252
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y253
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y254
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y255
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y26
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y27
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y28
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y29
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y3
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y30
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y31
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y32
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y33
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y34
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y35
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y36
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y37
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y38
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y39
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y4
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y40
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y41
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y42
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y43
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y44
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y45
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y46
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y47
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y48
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y49
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y5
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y50
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y51
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y52
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y53
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y54
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y55
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y56
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y57
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y58
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y59
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y6
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y60
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y61
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y62
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y63
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y64
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y65
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y66
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y67
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y68
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y69
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y7
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y70
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y71
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y72
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y73
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y74
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y75
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y76
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y77
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y78
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y79
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y8
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y80
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y81
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y82
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y83
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y84
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y85
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y86
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y87
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y88
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y89
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y9
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y90
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y91
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y92
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y93
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y94
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y95
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y96
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y97
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y98
+ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::boolean_ops::share_conversion_aby::Step::reveal_y99
 ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::convert_fp25519/ipa_core::protocol::ipa_prf::prf_eval::Step::p_r_f_key_gen
 ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::eval_prf
 ipa_core::protocol::ipa_prf::Step::convert_input_rows_to_prf/ipa_core::protocol::ipa_prf::Step::eval_prf/ipa_core::protocol::ipa_prf::prf_eval::Step::gen_random_mask
@@ -708,7 +963,42 @@ ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf
 ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass13/ipa_core::protocol::ipa_prf::quicksort::Step::reveal
 ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14
 ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit0
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit1
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit10
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit11
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit12
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit13
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit14
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit15
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit16
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit17
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit18
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit19
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit2
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit20
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit21
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit22
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit23
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit24
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit25
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit26
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit27
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit28
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit29
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit3
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit30
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit31
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit4
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit5
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit6
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit7
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit8
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit9
 ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass14/ipa_core::protocol::ipa_prf::quicksort::Step::reveal
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass15
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass15/ipa_core::protocol::ipa_prf::quicksort::Step::compare
+ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass15/ipa_core::protocol::ipa_prf::quicksort::Step::reveal
 ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass2
 ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass2/ipa_core::protocol::ipa_prf::quicksort::Step::compare
 ipa_core::protocol::ipa_prf::Step::sort_by_timestamp/ipa_core::protocol::ipa_prf::quicksort::Step::quicksort_pass2/ipa_core::protocol::ipa_prf::quicksort::Step::compare/ipa_core::protocol::step::BitOpStep::bit0
diff --git a/ipa-core/src/secret_sharing/decomposed.rs b/ipa-core/src/secret_sharing/decomposed.rs
index f15455a87..e96d8e322 100644
--- a/ipa-core/src/secret_sharing/decomposed.rs
+++ b/ipa-core/src/secret_sharing/decomposed.rs
@@ -6,8 +6,12 @@ use std::{
 
 use crate::{
     error::Error,
-    ff::{ArrayAccessRef, ArrayBuild, ArrayBuilder, PrimeField},
-    secret_sharing::{Linear as LinearSecretSharing, LinearRefOps},
+    ff::{boolean::Boolean, ArrayAccessRef, ArrayBuild, ArrayBuilder, PrimeField},
+    protocol::prss::{FromPrss, FromRandom, PrssIndex, SharedRandomness},
+    secret_sharing::{
+        replicated::semi_honest::AdditiveShare, Linear as LinearSecretSharing, LinearRefOps,
+        SharedValue, Vectorizable,
+    },
 };
 
 #[derive(Clone, Debug, PartialEq)]
@@ -103,12 +107,42 @@ impl<S> BitDecomposed<S> {
     }
 }
 
+// Provides BitDecomposed <-> BooleanArray interoperability. Otherwise just use `new`.
+impl<S> FromIterator<S> for BitDecomposed<S> {
+    fn from_iter<I: IntoIterator<Item = S>>(iter: I) -> Self {
+        Self::new(iter)
+    }
+}
+
 impl<S: Clone> BitDecomposed<S> {
     pub fn resize(&mut self, new_len: usize, value: S) {
         self.bits.resize(new_len, value);
     }
 }
 
+impl<A, const N: usize> FromPrss<usize> for BitDecomposed<AdditiveShare<Boolean, N>>
+where
+    A: SharedValue + FromRandom,
+    Boolean: Vectorizable<N, Array = A>,
+{
+    fn from_prss_with<P: SharedRandomness + ?Sized, I: Into<PrssIndex>>(
+        prss: &P,
+        index: I,
+        len: usize,
+    ) -> Self {
+        let bits = prss
+            .generate_chunks_iter::<_, <A as FromRandom>::SourceLength>(index)
+            .map(|(l_rand, r_rand)| {
+                let l_val = A::from_random(l_rand);
+                let r_val = A::from_random(r_rand);
+                AdditiveShare::new_arr(l_val, r_val)
+            })
+            .take(len)
+            .collect();
+        Self { bits }
+    }
+}
+
 impl<S> TryFrom<Vec<S>> for BitDecomposed<S> {
     type Error = Error;
     fn try_from(bits: Vec<S>) -> Result<Self, Self::Error> {
diff --git a/ipa-core/src/secret_sharing/mod.rs b/ipa-core/src/secret_sharing/mod.rs
index eb1838f0e..9e5e2453f 100644
--- a/ipa-core/src/secret_sharing/mod.rs
+++ b/ipa-core/src/secret_sharing/mod.rs
@@ -23,8 +23,8 @@ use rand::{
 };
 pub use scheme::{Bitwise, Linear, LinearRefOps, SecretSharing};
 pub use vector::{
-    FieldArray, FieldSimd, FieldVectorizable, SharedValueArray, StdArray, TransposeFrom,
-    Vectorizable,
+    BoolVectorLookup, BoolVectorTrait, FieldArray, FieldSimd, FieldVectorizable, SharedValueArray,
+    StdArray, TransposeFrom, Vectorizable,
 };
 
 #[cfg(any(test, feature = "test-fixture", feature = "cli"))]
diff --git a/ipa-core/src/secret_sharing/replicated/semi_honest/additive_share.rs b/ipa-core/src/secret_sharing/replicated/semi_honest/additive_share.rs
index c37bee4b1..55c5fbe2f 100644
--- a/ipa-core/src/secret_sharing/replicated/semi_honest/additive_share.rs
+++ b/ipa-core/src/secret_sharing/replicated/semi_honest/additive_share.rs
@@ -113,17 +113,20 @@ impl<V: SharedValue + Vectorizable<N>, const N: usize> AdditiveShare<V, N> {
         &mut self.1
     }
 
-    pub fn into_arr_tuple(self) -> (<V as Vectorizable<N>>::Array, <V as Vectorizable<N>>::Array) {
-        let Self(left, right) = self;
-        (left, right)
-    }
-
     pub fn from_fns<LF: FnMut(usize) -> V, RF: FnMut(usize) -> V>(lf: LF, rf: RF) -> Self {
         Self(
             <V as Vectorizable<N>>::Array::from_fn(lf),
             <V as Vectorizable<N>>::Array::from_fn(rf),
         )
     }
+
+    // Providing this as IntoIterator results in conflicting malicious upgrade implementations for
+    // AdditiveShare. It's not clear that the unpacking iterator is a universally appropriate thing
+    // to return from IntoIterator anyways.
+    pub fn into_unpacking_iter(self) -> UnpackIter<V, N> {
+        let Self(left, right) = self;
+        UnpackIter(left.into_iter(), right.into_iter())
+    }
 }
 
 impl<V: SharedValue> AdditiveShare<V>
@@ -476,6 +479,23 @@ where
     }
 }
 
+pub struct UnpackIter<S: SharedValue + Vectorizable<N>, const N: usize>(
+    <<S as Vectorizable<N>>::Array as IntoIterator>::IntoIter,
+    <<S as Vectorizable<N>>::Array as IntoIterator>::IntoIter,
+);
+
+impl<S: SharedValue + Vectorizable<N>, const N: usize> Iterator for UnpackIter<S, N> {
+    type Item = AdditiveShare<S>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match (self.0.next(), self.1.next()) {
+            (None, None) => None,
+            (Some(left), Some(right)) => Some(AdditiveShare::new(left, right)),
+            _ => unreachable!("unequal left/right length in vectorized AdditiveShare"),
+        }
+    }
+}
+
 pub struct AdditiveShareArrayBuilder<B>
 where
     B: ArrayBuilder,
diff --git a/ipa-core/src/secret_sharing/vector/array.rs b/ipa-core/src/secret_sharing/vector/array.rs
index ce3c22f14..a5ad37119 100644
--- a/ipa-core/src/secret_sharing/vector/array.rs
+++ b/ipa-core/src/secret_sharing/vector/array.rs
@@ -6,12 +6,13 @@ use std::{
 };
 
 use generic_array::{ArrayLength, GenericArray};
-use typenum::{U16, U256, U32, U64};
+use typenum::{U128, U16, U256, U32, U64};
 
 use crate::{
+    const_assert_eq,
     error::LengthError,
-    ff::{Field, Fp32BitPrime, Serializable},
-    protocol::prss::FromRandom,
+    ff::{ec_prime_field::Fp25519, Expand, Field, Fp32BitPrime, Serializable},
+    protocol::{ipa_prf::PRF_CHUNK, prss::FromRandom},
     secret_sharing::{FieldArray, Sendable, SharedValue, SharedValueArray},
 };
 
@@ -104,6 +105,31 @@ where
     }
 }
 
+impl<V: SharedValue, const N: usize> StdArray<V, N>
+where
+    Self: Sendable, // required for `<Self as SharedValueArray>::ZERO`
+{
+    /// Build a pair of `StdArray`s from an iterator over tuples.
+    ///
+    /// # Panics
+    /// If the iterator terminates before producing N items.
+    pub fn from_tuple_iter<T: IntoIterator<Item = (V, V)>>(iter: T) -> (Self, Self) {
+        let mut l_res = Self::ZERO_ARRAY;
+        let mut r_res = Self::ZERO_ARRAY;
+        let mut iter = iter.into_iter();
+
+        for i in 0..N {
+            let (l, r) = iter
+                .next()
+                .unwrap_or_else(|| panic!("Expected iterator to produce {N} items, got only {i}"));
+            l_res.0[i] = l;
+            r_res.0[i] = r;
+        }
+
+        (l_res, r_res)
+    }
+}
+
 impl<V: SharedValue, const N: usize> IntoIterator for StdArray<V, N> {
     type Item = V;
     type IntoIter = std::array::IntoIter<V, N>;
@@ -113,6 +139,14 @@ impl<V: SharedValue, const N: usize> IntoIterator for StdArray<V, N> {
     }
 }
 
+impl<V: SharedValue, const N: usize> Expand for StdArray<V, N> {
+    type Input = V;
+
+    fn expand(v: &Self::Input) -> Self {
+        Self(array::from_fn(|_| *v))
+    }
+}
+
 impl<'a, 'b, V: SharedValue, const N: usize> Add<&'b StdArray<V, N>> for &'a StdArray<V, N> {
     type Output = StdArray<V, N>;
 
@@ -293,6 +327,13 @@ macro_rules! impl_from_random {
     };
 }
 
+const_assert_eq!(
+    PRF_CHUNK,
+    64,
+    "Appropriate FromRandom implementation required"
+);
+impl_from_random!(Fp25519, 64, U128, 2);
+
 impl_from_random!(Fp32BitPrime, 32, U32, 1);
 
 impl<V: SharedValue> Serializable for StdArray<V, 1> {
diff --git a/ipa-core/src/secret_sharing/vector/impls.rs b/ipa-core/src/secret_sharing/vector/impls.rs
index 2ada6571c..9fffbc0c3 100644
--- a/ipa-core/src/secret_sharing/vector/impls.rs
+++ b/ipa-core/src/secret_sharing/vector/impls.rs
@@ -1,19 +1,24 @@
 //! Supported vectorizations
 
 use crate::{
+    const_assert_eq,
     ff::{
         boolean::Boolean,
         boolean_array::{BA16, BA20, BA256, BA3, BA32, BA5, BA64, BA8},
+        ec_prime_field::Fp25519,
         Fp32BitPrime,
     },
+    protocol::ipa_prf::{MK_BITS, PRF_CHUNK},
     secret_sharing::{
-        replicated::semi_honest::AdditiveShare, FieldSimd, FieldVectorizable,
-        ReplicatedSecretSharing, Vectorizable,
+        replicated::semi_honest::AdditiveShare, BitDecomposed, FieldSimd, FieldVectorizable,
+        ReplicatedSecretSharing, SharedValue, Vectorizable,
     },
 };
 
 impl FieldSimd<32> for Fp32BitPrime {}
 
+impl FieldSimd<PRF_CHUNK> for Fp25519 {}
+
 macro_rules! boolean_vector {
     ($dim:expr, $vec:ty) => {
         impl Vectorizable<$dim> for Boolean {
@@ -65,6 +70,38 @@ boolean_vector!(256, BA256);
 /// `BitDecomposed<AdditiveShare<Boolean, dim>>`.
 #[macro_export]
 macro_rules! BoolVector {
-    (16, 1) => { $crate::secret_sharing::replicated::semi_honest::AdditiveShare<$crate::ff::BA16> };
-    ($width:expr, $dim:expr) => { BitDecomposed<$crate::secret_sharing::replicated::semi_honest::AdditiveShare<$crate::ff::boolean::Boolean, $dim>> };
+    ($width:expr, $dim:expr) => {
+        <$crate::secret_sharing::BoolVectorLookup as $crate::secret_sharing::BoolVectorTrait<
+            $width,
+            $dim,
+        >>::Share
+    };
+}
+
+pub trait BoolVectorTrait<const B: usize, const N: usize> {
+    type Share;
+}
+
+pub struct BoolVectorLookup;
+
+const_assert_eq!(
+    MK_BITS,
+    64,
+    "Appropriate BoolVectorTrait implementation required"
+);
+impl BoolVectorTrait<64, 1> for BoolVectorLookup {
+    type Share = AdditiveShare<BA64>;
+}
+
+const_assert_eq!(
+    Fp25519::BITS,
+    256,
+    "Appropriate BoolVectorTrait implementation required"
+);
+impl BoolVectorTrait<256, 1> for BoolVectorLookup {
+    type Share = AdditiveShare<BA256>;
+}
+
+impl<const B: usize> BoolVectorTrait<B, PRF_CHUNK> for BoolVectorLookup {
+    type Share = BitDecomposed<AdditiveShare<Boolean, PRF_CHUNK>>;
 }
diff --git a/ipa-core/src/secret_sharing/vector/mod.rs b/ipa-core/src/secret_sharing/vector/mod.rs
index 4e4575af3..e4bb70c6e 100644
--- a/ipa-core/src/secret_sharing/vector/mod.rs
+++ b/ipa-core/src/secret_sharing/vector/mod.rs
@@ -54,6 +54,7 @@ mod traits;
 mod transpose;
 
 pub use array::StdArray;
+pub use impls::{BoolVectorLookup, BoolVectorTrait};
 pub use traits::{FieldArray, FieldSimd, FieldVectorizable, SharedValueArray, Vectorizable};
 pub use transpose::TransposeFrom;
 #[cfg(feature = "enable-benches")]
diff --git a/ipa-core/src/secret_sharing/vector/traits.rs b/ipa-core/src/secret_sharing/vector/traits.rs
index b44316b70..91da2f2e1 100644
--- a/ipa-core/src/secret_sharing/vector/traits.rs
+++ b/ipa-core/src/secret_sharing/vector/traits.rs
@@ -5,7 +5,7 @@ use std::{
 
 use crate::{
     error::LengthError,
-    ff::Field,
+    ff::{Expand, Field},
     protocol::prss::FromRandom,
     secret_sharing::{Sendable, SharedValue},
 };
@@ -96,6 +96,7 @@ pub trait SharedValueArray<V>:
     + for<'a> Sub<&'a Self, Output = Self>
     + SubAssign<Self>
     + for<'a> SubAssign<&'a Self>
+    + Expand<Input = V>
 {
     const ZERO_ARRAY: Self;
 
diff --git a/ipa-core/src/secret_sharing/vector/transpose.rs b/ipa-core/src/secret_sharing/vector/transpose.rs
index 020cdb9a6..d17a21b69 100644
--- a/ipa-core/src/secret_sharing/vector/transpose.rs
+++ b/ipa-core/src/secret_sharing/vector/transpose.rs
@@ -41,17 +41,40 @@ use std::borrow::Borrow;
 use std::{array, convert::Infallible};
 
 use crate::{
+    const_assert_eq,
     error::{LengthError, UnwrapInfallible},
     ff::{
         boolean::Boolean,
-        boolean_array::{BA16, BA256, BA64},
+        boolean_array::{BA256, BA64},
+        ec_prime_field::Fp25519,
     },
+    protocol::ipa_prf::{MK_BITS, PRF_CHUNK},
     secret_sharing::{
         replicated::{semi_honest::AdditiveShare, ReplicatedSecretSharing},
         BitDecomposed, SharedValue, StdArray,
     },
 };
 
+// The following constants are hardcoded in various places throughout this file (including in type
+// names like `BA256` where they cannot be substituted directly).
+//
+// The symbolic names are referenced in a comment adjacent to each use.
+const_assert_eq!(
+    Fp25519::BITS,
+    256,
+    "Appropriate transpose implementations required"
+);
+const_assert_eq!(
+    MK_BITS,
+    64,
+    "Appropriate transpose implementations required"
+);
+const_assert_eq!(
+    PRF_CHUNK,
+    64,
+    "Appropriate transpose implementations required"
+);
+
 /// Trait for overwriting a value with the transpose of a source value.
 pub trait TransposeFrom<T> {
     type Error;
@@ -152,26 +175,40 @@ pub fn transpose_16x16(src: &[u8; 32]) -> [u8; 32] {
     dst
 }
 
-// Degenerate transposes.
+// Degenerate transposes
+//
+// These can be particularly confusing, because an Mx1 matrix may be stored as a `BA{M}` rather
+// than a `[Boolean; M]`.
 
-impl TransposeFrom<AdditiveShare<BA256, 1>> for Vec<AdditiveShare<BA256>> {
+// Usage: Share conversion input (convert_to_fp25519 test). M = PRF_CHUNK, N = MK_BITS.
+impl<'a> TransposeFrom<&'a [AdditiveShare<BA64>; 1]> for AdditiveShare<BA64, 1> {
     type Error = Infallible;
-
-    fn transpose_from(&mut self, src: AdditiveShare<BA256, 1>) -> Result<(), Infallible> {
-        *self = vec![src];
+    fn transpose_from(&mut self, src: &'a [AdditiveShare<BA64>; 1]) -> Result<(), Infallible> {
+        *self = src[0].clone();
         Ok(())
     }
 }
 
-impl TransposeFrom<Vec<StdArray<Boolean, 1>>> for Vec<BA256> {
+// Usage: Share conversion output (r/s). M = Fp25519::BITS, N = PRF_CHUNK.
+impl<'a> TransposeFrom<&'a AdditiveShare<BA256, 1>> for Vec<AdditiveShare<BA256>> {
     type Error = Infallible;
+    fn transpose_from(&mut self, src: &'a AdditiveShare<BA256, 1>) -> Result<(), Infallible> {
+        *self = vec![src.clone()];
+        Ok(())
+    }
+}
 
-    fn transpose_from(&mut self, src: Vec<StdArray<Boolean, 1>>) -> Result<(), Infallible> {
+// Usage: Share conversion output (y). M = Fp25519::BITS, N = PRF_CHUNK.
+impl<'a> TransposeFrom<&'a [StdArray<Boolean, 1>; 256]> for Vec<BA256> {
+    type Error = Infallible;
+    fn transpose_from(&mut self, src: &'a [StdArray<Boolean, 1>; 256]) -> Result<(), Infallible> {
         *self = vec![src.iter().map(Boolean::from_array).collect::<BA256>()];
         Ok(())
     }
 }
 
+// Matrix transpose helpers
+
 /// Perform a larger transpose using an 16x16 kernel.
 ///
 /// Matrix height and width must be multiples of 16.
@@ -259,15 +296,16 @@ macro_rules! impl_transpose_ba_to_ba {
     };
 }
 
-impl_transpose_ba_to_ba!(BA16, BA64, 16, 64, test_transpose_ba_16x64);
+// Usage: Transpose benchmark.
 impl_transpose_ba_to_ba!(BA64, BA64, 64, 64, test_transpose_ba_64x64);
+
+// Usage: Share conversion output (y). M = Fp25519::BITS, N = PRF_CHUNK.
 impl_transpose_ba_to_ba!(BA256, BA64, 256, 64, test_transpose_ba_256x64);
-impl_transpose_ba_to_ba!(BA256, BA256, 256, 256, test_transpose_ba_256x256);
 
 /// Implement a transpose of a MxN matrix of secret-shared bits represented as
 /// `[AdditiveShare<Boolean, N>; <M>]` into a NxM bit matrix represented as `[AdditiveShare<BA<M>>; N]`.
 ///
-/// For MxN = 256x64, the invocation looks like `impl_transpose_bool_to_ba!(BA256, 256, 64)`.
+/// For MxN = 256x64, the invocation looks like `impl_transpose_shares_bool_to_ba!(BA256, 256, 64)`.
 macro_rules! impl_transpose_shares_bool_to_ba {
     ($dst_row:ty, $src_rows:expr, $src_cols:expr, $test_fn:ident) => {
         impl TransposeFrom<&[AdditiveShare<Boolean, $src_cols>; $src_rows]>
@@ -355,27 +393,22 @@ macro_rules! impl_transpose_shares_bool_to_ba {
     };
 }
 
-impl_transpose_shares_bool_to_ba!(BA256, 256, 16, test_transpose_shares_bool_to_ba_256x16);
+// Usage: Share conversion output (r/s). M = Fp25519::BITS, N = PRF_CHUNK.
 impl_transpose_shares_bool_to_ba!(BA256, 256, 64, test_transpose_shares_bool_to_ba_256x64);
-impl_transpose_shares_bool_to_ba!(BA256, 256, 256, test_transpose_shares_bool_to_ba_256x256);
 
-/// Implement a transpose of a MxN matrix of secret-shared bits accessed via
-/// `Fn(usize) -> AdditiveShare<BA{N}>` into a NxM bit matrix represented as `[AdditiveShare<Boolean, M>; N]`.
+/// Implement a transpose of a MxN matrix of secret-shared bits represented as
+/// `[AdditiveShare<BA<N>>; M]` into a NxM bit matrix represented as `[AdditiveShare<Boolean, M>; N]`.
 ///
-/// For MxN = 256x64, the invocation looks like `impl_transpose_shares_ba_fn_to_bool!(BA64, 256, 64)`.
-macro_rules! impl_transpose_shares_ba_fn_to_bool {
+/// For MxN = 16x64, the invocation looks like `impl_transpose_shares_ba_to_bool!(BA64, 16, 64)`.
+macro_rules! impl_transpose_shares_ba_to_bool {
     ($src_row:ty, $src_rows:expr, $src_cols:expr, $test_fn:ident) => {
-        // This function-based access to the source is useful when the source is not contiguous in
-        // memory (i.e. accessing the match key for each input record). However, it does not
-        // optimize as well as the other implementations (even without the dynamic dispatch).
-        impl TransposeFrom<&dyn Fn(usize) -> AdditiveShare<$src_row>>
+        impl TransposeFrom<&[AdditiveShare<$src_row>; $src_rows]>
             for [AdditiveShare<Boolean, $src_rows>; $src_cols]
         {
             type Error = Infallible;
-
             fn transpose_from(
                 &mut self,
-                src: &dyn Fn(usize) -> AdditiveShare<$src_row>,
+                src: &[AdditiveShare<$src_row>; $src_rows],
             ) -> Result<(), Infallible> {
                 // Transpose left share
                 do_transpose_16(
@@ -385,7 +418,7 @@ macro_rules! impl_transpose_shares_ba_fn_to_bool {
                         let mut d = [0u8; 32];
                         for k in 0..16 {
                             d[2 * k..2 * (k + 1)].copy_from_slice(
-                                &src(16 * i + k).left().as_raw_slice()[2 * j..2 * (j + 1)],
+                                &src[16 * i + k].left().as_raw_slice()[2 * j..2 * (j + 1)],
                             );
                         }
                         d
@@ -405,7 +438,7 @@ macro_rules! impl_transpose_shares_ba_fn_to_bool {
                         let mut d = [0u8; 32];
                         for k in 0..16 {
                             d[2 * k..2 * (k + 1)].copy_from_slice(
-                                &src(16 * i + k).right().as_raw_slice()[2 * j..2 * (j + 1)],
+                                &src[16 * i + k].right().as_raw_slice()[2 * j..2 * (j + 1)],
                             );
                         }
                         d
@@ -421,14 +454,19 @@ macro_rules! impl_transpose_shares_ba_fn_to_bool {
             }
         }
 
-        impl TransposeFrom<&dyn Fn(usize) -> AdditiveShare<$src_row>>
+        #[cfg(all(test, unit_test))]
+        #[test]
+        fn $test_fn() {
+            tests::test_transpose_shares_ba_to_bool::<$src_row, $src_rows, $src_cols>();
+        }
+
+        impl TransposeFrom<&[AdditiveShare<$src_row>; $src_rows]>
             for BitDecomposed<AdditiveShare<Boolean, $src_rows>>
         {
             type Error = Infallible;
-
             fn transpose_from(
                 &mut self,
-                src: &dyn Fn(usize) -> AdditiveShare<$src_row>,
+                src: &[AdditiveShare<$src_row>; $src_rows],
             ) -> Result<(), Infallible> {
                 self.resize($src_cols, AdditiveShare::<Boolean, $src_rows>::ZERO);
                 let dst =
@@ -440,23 +478,27 @@ macro_rules! impl_transpose_shares_ba_fn_to_bool {
     };
 }
 
-impl_transpose_shares_ba_fn_to_bool!(BA64, 16, 64, test_transpose_shares_ba_fn_to_bool_16x64);
-impl_transpose_shares_ba_fn_to_bool!(BA64, 256, 64, test_transpose_shares_ba_fn_to_bool_256x64);
+// Usage: Share conversion input (convert_to_fp25519 test). M = PRF_CHUNK, N = MK_BITS.
+// Note first macro argument is `BA{N}`, not `BA{M}`.
+impl_transpose_shares_ba_to_bool!(BA64, 64, 64, test_transpose_shares_ba_to_bool_64x64);
 
-/// Implement a transpose of a MxN matrix of secret-shared bits represented as
-/// `[AdditiveShare<Boolean, N>; <M>]` into a NxM bit matrix represented as `[AdditiveShare<Boolean<M>>; N]`.
+/// Implement a transpose of a MxN matrix of secret-shared bits accessed via
+/// `Fn(usize) -> AdditiveShare<BA{N}>` into a NxM bit matrix represented as `[AdditiveShare<Boolean, M>; N]`.
 ///
-/// For MxN = 256x64, the invocation looks like `impl_transpose_bool_to_bool!(BA64, 256, 64)`.
-macro_rules! impl_transpose_shares_bool_to_bool {
+/// For MxN = 256x64, the invocation looks like `impl_transpose_shares_ba_fn_to_bool!(BA64, 256, 64)`.
+macro_rules! impl_transpose_shares_ba_fn_to_bool {
     ($src_row:ty, $src_rows:expr, $src_cols:expr, $test_fn:ident) => {
-        impl TransposeFrom<&[AdditiveShare<Boolean, $src_cols>; $src_rows]>
+        // This function-based access to the source is useful when the source is not contiguous in
+        // memory (i.e. accessing the match key for each input record). However, it does not
+        // optimize as well as the other implementations (even without the dynamic dispatch).
+        impl TransposeFrom<&dyn Fn(usize) -> AdditiveShare<$src_row>>
             for [AdditiveShare<Boolean, $src_rows>; $src_cols]
         {
             type Error = Infallible;
 
             fn transpose_from(
                 &mut self,
-                src: &[AdditiveShare<Boolean, $src_cols>; $src_rows],
+                src: &dyn Fn(usize) -> AdditiveShare<$src_row>,
             ) -> Result<(), Infallible> {
                 // Transpose left share
                 do_transpose_16(
@@ -466,7 +508,7 @@ macro_rules! impl_transpose_shares_bool_to_bool {
                         let mut d = [0u8; 32];
                         for k in 0..16 {
                             d[2 * k..2 * (k + 1)].copy_from_slice(
-                                &src[16 * i + k].left_arr().as_raw_slice()[2 * j..2 * (j + 1)],
+                                &src(16 * i + k).left().as_raw_slice()[2 * j..2 * (j + 1)],
                             );
                         }
                         d
@@ -486,7 +528,7 @@ macro_rules! impl_transpose_shares_bool_to_bool {
                         let mut d = [0u8; 32];
                         for k in 0..16 {
                             d[2 * k..2 * (k + 1)].copy_from_slice(
-                                &src[16 * i + k].right_arr().as_raw_slice()[2 * j..2 * (j + 1)],
+                                &src(16 * i + k).right().as_raw_slice()[2 * j..2 * (j + 1)],
                             );
                         }
                         d
@@ -505,34 +547,17 @@ macro_rules! impl_transpose_shares_bool_to_bool {
         #[cfg(all(test, unit_test))]
         #[test]
         fn $test_fn() {
-            tests::test_transpose_shares_bool_to_bool::<$src_rows, $src_cols>();
+            tests::test_transpose_shares_ba_fn_to_bool::<$src_row, $src_rows, $src_cols>();
         }
 
-        impl TransposeFrom<&[AdditiveShare<Boolean, $src_cols>]>
-            for BitDecomposed<AdditiveShare<Boolean, $src_rows>>
-        {
-            type Error = LengthError;
-            fn transpose_from(
-                &mut self,
-                src: &[AdditiveShare<Boolean, $src_cols>],
-            ) -> Result<(), LengthError> {
-                let src = <&[AdditiveShare<Boolean, $src_cols>; $src_rows]>::try_from(src)
-                    .map_err(|_| LengthError {
-                        expected: $src_rows,
-                        actual: src.len(),
-                    })?;
-                self.transpose_from(src).unwrap_infallible();
-                Ok(())
-            }
-        }
-
-        impl TransposeFrom<&[AdditiveShare<Boolean, $src_cols>; $src_rows]>
+        impl TransposeFrom<&dyn Fn(usize) -> AdditiveShare<$src_row>>
             for BitDecomposed<AdditiveShare<Boolean, $src_rows>>
         {
             type Error = Infallible;
+
             fn transpose_from(
                 &mut self,
-                src: &[AdditiveShare<Boolean, $src_cols>; $src_rows],
+                src: &dyn Fn(usize) -> AdditiveShare<$src_row>,
             ) -> Result<(), Infallible> {
                 self.resize($src_cols, AdditiveShare::<Boolean, $src_rows>::ZERO);
                 let dst =
@@ -544,15 +569,12 @@ macro_rules! impl_transpose_shares_bool_to_bool {
     };
 }
 
-impl_transpose_shares_bool_to_bool!(BA64, 16, 64, test_transpose_shares_bool_to_bool_16x64);
-impl_transpose_shares_bool_to_bool!(BA64, 64, 64, test_transpose_shares_bool_to_bool_64x64);
-impl_transpose_shares_bool_to_bool!(BA64, 256, 64, test_transpose_shares_bool_to_bool_256x64);
+// Usage: Share conversion input (compute_prf_for_inputs). M = PRF_CHUNK, N = MK_BITS.
+// Note first macro argument is `BA{N}`, not `BA{M}`.
+impl_transpose_shares_ba_fn_to_bool!(BA64, 64, 64, test_transpose_shares_ba_fn_to_bool_64x64);
 
 #[cfg(all(test, unit_test))]
 mod tests {
-    // Using `.enumerate()` would just obfuscate the nested for loops verifying transposes.
-    #![allow(clippy::needless_range_loop)]
-
     use std::{
         cmp::min,
         fmt::Debug,
@@ -626,6 +648,19 @@ mod tests {
     impl_byte_conversion!([u32; 32], [u8; 128]);
     impl_byte_conversion!([u64; 64], [u8; 512]);
 
+    fn verify_transpose<T, F1, F2>(src_rows: usize, src_cols: usize, transposed: F1, original: F2)
+    where
+        T: PartialEq + Debug,
+        F1: Fn(usize, usize) -> T,
+        F2: Fn(usize, usize) -> T,
+    {
+        for i in 0..src_cols {
+            for j in 0..src_rows {
+                assert_eq!(transposed(i, j), original(j, i));
+            }
+        }
+    }
+
     fn test_transpose_array<
         T,               // Matrix integer type (e.g. u16 for 16x16)
         const N: usize,  // Matrix dimension
@@ -667,11 +702,7 @@ mod tests {
         let m = <[T; N]>::from_bytes(m);
         let m_t = <[T; N]>::from_bytes(m_t);
 
-        for i in 0..N {
-            for j in 0..N {
-                assert_eq!((m_t[i] >> j) & one, (m[j] >> i) & one);
-            }
-        }
+        verify_transpose(N, N, |i, j| (m_t[i] >> j) & one, |i, j| (m[i] >> j) & one);
     }
 
     #[test]
@@ -684,6 +715,48 @@ mod tests {
         test_transpose_array::<u16, 16, 32>(super::transpose_16x16);
     }
 
+    fn ba_shares_test_matrix<BA, const M: usize, const N: usize>(
+        step: usize,
+    ) -> [AdditiveShare<BA>; M]
+    where
+        BA: SharedValue + FromIterator<Boolean> + Vectorizable<1, Array = StdArray<BA, 1>>,
+    {
+        array::from_fn(|i| {
+            let mut left = vec![Boolean::FALSE; N];
+            let mut right = vec![Boolean::FALSE; N];
+            for j in ((i % N)..N).step_by(step) {
+                let b = Boolean::from(j % 2 != 0);
+                left[j] = b;
+                right[j] = !b;
+            }
+            AdditiveShare::new_arr(
+                BA::from_iter(left).into_array(),
+                BA::from_iter(right).into_array(),
+            )
+        })
+    }
+
+    fn bool_shares_test_matrix<const M: usize, const N: usize>(
+        step: usize,
+    ) -> [AdditiveShare<Boolean, N>; M]
+    where
+        Boolean: Vectorizable<N>,
+    {
+        array::from_fn(|i| {
+            let mut left = vec![Boolean::FALSE; N];
+            let mut right = vec![Boolean::FALSE; N];
+            for j in ((i % N)..N).step_by(step) {
+                let b = Boolean::from(j % 2 != 0);
+                left[j] = b;
+                right[j] = !b;
+            }
+            AdditiveShare::new_arr(
+                <Boolean as Vectorizable<N>>::Array::from_iter(left),
+                <Boolean as Vectorizable<N>>::Array::from_iter(right),
+            )
+        })
+    }
+
     // The order of type parameters matches the implementation macro: BA<m>, BA<n>, <m>, <n>
     pub(super) fn test_transpose_ba_to_ba<
         DR,              // Destination row type
@@ -727,91 +800,67 @@ mod tests {
         let m = repeat_with(|| rng.gen()).take(SM).collect::<Vec<_>>();
         let m_t = t_impl(<&[SR; SM]>::try_from(m.as_slice()).unwrap());
 
-        for i in 0..DM {
-            for j in 0..SM {
-                assert_eq!(m_t[i].get(j), m[j].get(i));
-            }
-        }
+        verify_transpose(SM, DM, |i, j| m_t[i].get(j), |i, j| m[i].get(j));
     }
 
-    // The order of type parameters matches the implementation macro: BA<m>, <m>, <n>
-    pub(super) fn test_transpose_shares_bool_to_ba<
-        DR,              // Destination row type
+    // The order of type parameters matches the implementation macro: BA<n>, <m>, <n>
+    pub(super) fn test_transpose_shares_ba_to_bool<
+        SR,              // Source row type
         const SM: usize, // Source rows (== dest cols)
         const DM: usize, // Destination rows (== source cols)
     >()
     where
-        Boolean: Vectorizable<DM>,
-        <Boolean as Vectorizable<DM>>::Array: ArrayAccess<Output = Boolean>,
-        DR: SharedValue + ArrayAccess<Output = Boolean>,
-        [AdditiveShare<DR>; DM]:
-            for<'a> TransposeFrom<&'a [AdditiveShare<Boolean, DM>; SM], Error = Infallible>,
+        Boolean: Vectorizable<SM>,
+        <Boolean as Vectorizable<SM>>::Array: ArrayAccess<Output = Boolean>,
+        SR: SharedValue
+            + ArrayAccess<Output = Boolean>
+            + FromIterator<Boolean>
+            + Vectorizable<1, Array = StdArray<SR, 1>>,
+        [AdditiveShare<Boolean, SM>; DM]:
+            for<'a> TransposeFrom<&'a [AdditiveShare<SR>; SM], Error = Infallible>,
+        Standard: Distribution<SR>,
     {
         let t_impl = |src| {
-            let mut dst = [AdditiveShare::<DR>::ZERO; DM];
+            let mut dst = [AdditiveShare::<Boolean, SM>::ZERO; DM];
             dst.transpose_from(src).unwrap_infallible();
             dst
         };
 
         let step = min(SM, DM);
-        let m = array::from_fn(|i| {
-            let mut left = vec![Boolean::FALSE; DM];
-            let mut right = vec![Boolean::FALSE; DM];
-            for j in ((i % DM)..DM).step_by(step) {
-                let b = Boolean::from(j % 2 != 0);
-                left[j] = b;
-                right[j] = !b;
-            }
-            AdditiveShare::new_arr(
-                <Boolean as Vectorizable<DM>>::Array::from_iter(left),
-                <Boolean as Vectorizable<DM>>::Array::from_iter(right),
-            )
-        });
+        let m = ba_shares_test_matrix::<SR, SM, DM>(step);
         let m_t = t_impl(&m);
-        assert_eq!(
-            m_t,
-            array::from_fn(|i| {
-                let mut v = AdditiveShare::<DR>::ZERO;
-                for j in ((i % SM)..SM).step_by(step) {
-                    let b = Boolean::from(j % 2 != 0);
-                    v.set(j, AdditiveShare::new(b, !b));
-                }
-                v
-            })
-        );
+        assert_eq!(m_t, bool_shares_test_matrix::<DM, SM>(step));
 
         let mut left_rng = thread_rng();
         let mut right_rng = thread_rng();
         let m = repeat_with(|| AdditiveShare::from_fns(|_| left_rng.gen(), |_| right_rng.gen()))
             .take(SM)
             .collect::<Vec<_>>();
-        let m_t = t_impl(<&[AdditiveShare<Boolean, DM>; SM]>::try_from(m.as_slice()).unwrap());
+        let m_t = t_impl(<&[AdditiveShare<SR>; SM]>::try_from(m.as_slice()).unwrap());
 
-        for i in 0..DM {
-            for j in 0..SM {
-                assert_eq!(
-                    m_t[i].get(j).unwrap().left(),
-                    m[j].left_arr().get(i).unwrap()
-                );
-                assert_eq!(
-                    m_t[i].get(j).unwrap().right(),
-                    m[j].right_arr().get(i).unwrap()
-                );
-            }
-        }
+        #[rustfmt::skip]
+        verify_transpose(SM, DM,
+            |i, j| (m_t[i].left_arr().get(j).unwrap(), m_t[i].right_arr().get(j).unwrap()),
+            |i, j| (m[i].get(j).unwrap().left(), m[i].get(j).unwrap().right()),
+        );
     }
 
-    pub(super) fn test_transpose_shares_bool_to_bool<
+    // The order of type parameters matches the implementation macro: BA<n>, <m>, <n>
+    pub(super) fn test_transpose_shares_ba_fn_to_bool<
+        SR,              // Source row type
         const SM: usize, // Source rows (== dest cols)
         const DM: usize, // Destination rows (== source cols)
     >()
     where
-        Boolean: Vectorizable<DM>,
-        <Boolean as Vectorizable<DM>>::Array: ArrayAccess<Output = Boolean>,
         Boolean: Vectorizable<SM>,
         <Boolean as Vectorizable<SM>>::Array: ArrayAccess<Output = Boolean>,
+        SR: SharedValue
+            + ArrayAccess<Output = Boolean>
+            + FromIterator<Boolean>
+            + Vectorizable<1, Array = StdArray<SR, 1>>,
         [AdditiveShare<Boolean, SM>; DM]:
-            for<'a> TransposeFrom<&'a [AdditiveShare<Boolean, DM>; SM], Error = Infallible>,
+            for<'a> TransposeFrom<&'a dyn Fn(usize) -> AdditiveShare<SR>, Error = Infallible>,
+        Standard: Distribution<SR>,
     {
         let t_impl = |src| {
             let mut dst = [AdditiveShare::<Boolean, SM>::ZERO; DM];
@@ -820,36 +869,52 @@ mod tests {
         };
 
         let step = min(SM, DM);
-        let m = array::from_fn(|i| {
-            let mut left = vec![Boolean::FALSE; DM];
-            let mut right = vec![Boolean::FALSE; DM];
-            for j in ((i % DM)..DM).step_by(step) {
-                let b = Boolean::from(j % 2 != 0);
-                left[j] = b;
-                right[j] = !b;
-            }
-            AdditiveShare::new_arr(
-                <Boolean as Vectorizable<DM>>::Array::from_iter(left),
-                <Boolean as Vectorizable<DM>>::Array::from_iter(right),
-            )
-        });
-        let m_t = t_impl(&m);
-        assert_eq!(
-            m_t,
-            array::from_fn(|i| {
-                let mut left = vec![Boolean::FALSE; SM];
-                let mut right = vec![Boolean::FALSE; SM];
-                for j in ((i % SM)..SM).step_by(step) {
-                    let b = Boolean::from(j % 2 != 0);
-                    left[j] = b;
-                    right[j] = !b;
-                }
-                AdditiveShare::new_arr(
-                    <Boolean as Vectorizable<SM>>::Array::from_iter(left),
-                    <Boolean as Vectorizable<SM>>::Array::from_iter(right),
-                )
-            })
+        let m = ba_shares_test_matrix::<SR, SM, DM>(step);
+        let m_func = |i| AdditiveShare::<SR>::clone(&m[i]);
+        let m_t = t_impl(&m_func);
+        assert_eq!(m_t, bool_shares_test_matrix::<DM, SM>(step));
+
+        let mut left_rng = thread_rng();
+        let mut right_rng = thread_rng();
+        let m = repeat_with(|| AdditiveShare::from_fns(|_| left_rng.gen(), |_| right_rng.gen()))
+            .take(SM)
+            .collect::<Vec<_>>();
+        let m_func = |i| AdditiveShare::<SR>::clone(&m[i]);
+        let m_t = t_impl(&m_func);
+
+        #[rustfmt::skip]
+        verify_transpose(SM, DM,
+            |i, j| (m_t[i].left_arr().get(j).unwrap(), m_t[i].right_arr().get(j).unwrap()),
+            |i, j| (m[i].get(j).unwrap().left(), m[i].get(j).unwrap().right()),
         );
+    }
+
+    // The order of type parameters matches the implementation macro: BA<m>, <m>, <n>
+    pub(super) fn test_transpose_shares_bool_to_ba<
+        DR,              // Destination row type
+        const SM: usize, // Source rows (== dest cols)
+        const DM: usize, // Destination rows (== source cols)
+    >()
+    where
+        Boolean: Vectorizable<DM>,
+        <Boolean as Vectorizable<DM>>::Array: ArrayAccess<Output = Boolean>,
+        DR: SharedValue
+            + ArrayAccess<Output = Boolean>
+            + FromIterator<Boolean>
+            + Vectorizable<1, Array = StdArray<DR, 1>>,
+        [AdditiveShare<DR>; DM]:
+            for<'a> TransposeFrom<&'a [AdditiveShare<Boolean, DM>; SM], Error = Infallible>,
+    {
+        let t_impl = |src| {
+            let mut dst = [AdditiveShare::<DR>::ZERO; DM];
+            dst.transpose_from(src).unwrap_infallible();
+            dst
+        };
+
+        let step = min(SM, DM);
+        let m = bool_shares_test_matrix::<SM, DM>(step);
+        let m_t = t_impl(&m);
+        assert_eq!(m_t, ba_shares_test_matrix::<DR, DM, SM>(step));
 
         let mut left_rng = thread_rng();
         let mut right_rng = thread_rng();
@@ -858,17 +923,10 @@ mod tests {
             .collect::<Vec<_>>();
         let m_t = t_impl(<&[AdditiveShare<Boolean, DM>; SM]>::try_from(m.as_slice()).unwrap());
 
-        for i in 0..DM {
-            for j in 0..SM {
-                assert_eq!(
-                    m_t[i].left_arr().get(j).unwrap(),
-                    m[j].left_arr().get(i).unwrap()
-                );
-                assert_eq!(
-                    m_t[i].right_arr().get(j).unwrap(),
-                    m[j].right_arr().get(i).unwrap()
-                );
-            }
-        }
+        #[rustfmt::skip]
+        verify_transpose(SM, DM,
+            |i, j| (m_t[i].get(j).unwrap().left(), m_t[i].get(j).unwrap().right()),
+            |i, j| (m[i].left_arr().get(j).unwrap(), m[i].right_arr().get(j).unwrap()),
+        );
     }
 }