diff --git a/src/fri/recursive_verifier.rs b/src/fri/recursive_verifier.rs
index 29a6ff4f..1e028255 100644
--- a/src/fri/recursive_verifier.rs
+++ b/src/fri/recursive_verifier.rs
@@ -339,7 +339,12 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
             let x_index_within_coset = self.le_sum(x_index_within_coset_bits.iter());
 
             // Check consistency with our old evaluation from the previous round.
-            self.random_access(x_index_within_coset, old_eval, evals.clone());
+            self.random_access_padded(
+                x_index_within_coset,
+                old_eval,
+                evals.clone(),
+                1 << config.cap_height,
+            );
 
             // Infer P(y) from {P(x)}_{x^arity=y}.
             old_eval = with_context!(
diff --git a/src/gadgets/random_access.rs b/src/gadgets/random_access.rs
index 395d920e..febc44bf 100644
--- a/src/gadgets/random_access.rs
+++ b/src/gadgets/random_access.rs
@@ -11,7 +11,7 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
         &mut self,
         access_index: Target,
         claimed_element: ExtensionTarget<D>,
-        v: Vec<ExtensionTarget<D>>,
+        mut v: Vec<ExtensionTarget<D>>,
     ) {
         let gate = RandomAccessGate::new(v.len());
         let gate_index = self.add_gate(gate.clone(), vec![]);
@@ -31,6 +31,22 @@ impl<F: Extendable<D>, const D: usize> CircuitBuilder<F, D> {
             ExtensionTarget::from_range(gate_index, gate.wires_claimed_element()),
         );
     }
+
+    /// Like `random_access`, but first pads `v` to a given minimum length. This can help to avoid
+    /// having multiple `RandomAccessGate`s with different sizes.
+    pub fn random_access_padded(
+        &mut self,
+        access_index: Target,
+        claimed_element: ExtensionTarget<D>,
+        mut v: Vec<ExtensionTarget<D>>,
+        min_length: usize,
+    ) {
+        let zero = self.zero_extension();
+        if v.len() < min_length {
+            v.resize(8, zero);
+        }
+        self.random_access(access_index, claimed_element, v);
+    }
 }
 
 #[cfg(test)]
diff --git a/src/gates/exponentiation.rs b/src/gates/exponentiation.rs
index a1ef69f6..5b4075bd 100644
--- a/src/gates/exponentiation.rs
+++ b/src/gates/exponentiation.rs
@@ -72,7 +72,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ExponentiationGate<F, D> {
 
         let output = vars.local_wires[self.wire_output()];
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
 
         for i in 0..self.num_power_bits {
             let prev_intermediate_value = if i == 0 {
@@ -107,7 +107,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ExponentiationGate<F, D> {
 
         let output = vars.local_wires[self.wire_output()];
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
 
         for i in 0..self.num_power_bits {
             let prev_intermediate_value = if i == 0 {
@@ -146,7 +146,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ExponentiationGate<F, D> {
 
         let output = vars.local_wires[self.wire_output()];
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
 
         let one = builder.one_extension();
         for i in 0..self.num_power_bits {
diff --git a/src/gates/insertion.rs b/src/gates/insertion.rs
index a793463e..2e0ac8a1 100644
--- a/src/gates/insertion.rs
+++ b/src/gates/insertion.rs
@@ -85,7 +85,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for InsertionGate<F, D> {
             .collect::<Vec<_>>();
         let element_to_insert = vars.get_local_ext_algebra(self.wires_element_to_insert());
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
         let mut already_inserted = F::Extension::ZERO;
         for r in 0..=self.vec_size {
             let cur_index = F::Extension::from_canonical_usize(r);
@@ -123,7 +123,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for InsertionGate<F, D> {
             .collect::<Vec<_>>();
         let element_to_insert = vars.get_local_ext(self.wires_element_to_insert());
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
         let mut already_inserted = F::ZERO;
         for r in 0..=self.vec_size {
             let cur_index = F::from_canonical_usize(r);
@@ -165,7 +165,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for InsertionGate<F, D> {
             .collect::<Vec<_>>();
         let element_to_insert = vars.get_local_ext_algebra(self.wires_element_to_insert());
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
         let mut already_inserted = builder.constant_extension(F::Extension::ZERO);
         for r in 0..=self.vec_size {
             let cur_index_ext = F::Extension::from_canonical_usize(r);
diff --git a/src/gates/random_access.rs b/src/gates/random_access.rs
index 21667f49..07173de5 100644
--- a/src/gates/random_access.rs
+++ b/src/gates/random_access.rs
@@ -73,7 +73,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGate<F, D> {
             .collect::<Vec<_>>();
         let claimed_element = vars.get_local_ext_algebra(self.wires_claimed_element());
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
         for i in 0..self.vec_size {
             let cur_index = F::Extension::from_canonical_usize(i);
             let difference = cur_index - access_index;
@@ -99,7 +99,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGate<F, D> {
             .collect::<Vec<_>>();
         let claimed_element = vars.get_local_ext(self.wires_claimed_element());
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
         for i in 0..self.vec_size {
             let cur_index = F::from_canonical_usize(i);
             let difference = cur_index - access_index;
@@ -130,7 +130,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for RandomAccessGate<F, D> {
             .collect::<Vec<_>>();
         let claimed_element = vars.get_local_ext_algebra(self.wires_claimed_element());
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(self.num_constraints());
         for i in 0..self.vec_size {
             let cur_index_ext = F::Extension::from_canonical_usize(i);
             let cur_index = builder.constant_extension(cur_index_ext);
diff --git a/src/gates/reducing.rs b/src/gates/reducing.rs
index f3799b10..8bfdc0c4 100644
--- a/src/gates/reducing.rs
+++ b/src/gates/reducing.rs
@@ -66,7 +66,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ReducingGate<D> {
             .map(|i| vars.get_local_ext_algebra(self.wires_accs(i)))
             .collect::<Vec<_>>();
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(<Self as Gate<F, D>>::num_constraints(self));
         let mut acc = old_acc;
         for i in 0..self.num_coeffs {
             constraints.push(acc * alpha + coeffs[i].into() - accs[i]);
@@ -90,17 +90,14 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ReducingGate<D> {
             .map(|i| vars.get_local_ext(self.wires_accs(i)))
             .collect::<Vec<_>>();
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(<Self as Gate<F, D>>::num_constraints(self));
         let mut acc = old_acc;
         for i in 0..self.num_coeffs {
-            constraints.push(acc * alpha + coeffs[i].into() - accs[i]);
+            constraints.extend((acc * alpha + coeffs[i].into() - accs[i]).to_basefield_array());
             acc = accs[i];
         }
 
         constraints
-            .into_iter()
-            .flat_map(|alg| alg.to_basefield_array())
-            .collect()
     }
 
     fn eval_unfiltered_recursively(
@@ -118,7 +115,7 @@ impl<F: Extendable<D>, const D: usize> Gate<F, D> for ReducingGate<D> {
             .map(|i| vars.get_local_ext_algebra(self.wires_accs(i)))
             .collect::<Vec<_>>();
 
-        let mut constraints = Vec::new();
+        let mut constraints = Vec::with_capacity(<Self as Gate<F, D>>::num_constraints(self));
         let mut acc = old_acc;
         for i in 0..self.num_coeffs {
             let coeff = builder.convert_to_ext_algebra(coeffs[i]);