diff --git a/triton-vm/src/fri.rs b/triton-vm/src/fri.rs
index 3f92a295..681c7d16 100644
--- a/triton-vm/src/fri.rs
+++ b/triton-vm/src/fri.rs
@@ -1,10 +1,8 @@
 use itertools::Itertools;
-use ndarray::ArrayView1;
 use num_traits::Zero;
 use rayon::prelude::*;
 use std::ops::Mul;
 use twenty_first::math::traits::FiniteField;
-use twenty_first::math::traits::PrimitiveRootOfUnity;
 use twenty_first::prelude::*;
 
 use crate::arithmetic_domain::ArithmeticDomain;
@@ -640,47 +638,6 @@ pub fn barycentric_evaluate<FF: FiniteField + Mul<XFieldElement, Output = XField
     twenty_first::math::polynomial::barycentric_evaluate(codeword, indeterminate)
 }
 
-pub(crate) fn batch_barycentric_preprocess(
-    codeword_length: usize,
-    indeterminate: XFieldElement,
-) -> (Vec<XFieldElement>, XFieldElement) {
-    let root_order = codeword_length.try_into().unwrap();
-    let generator = BFieldElement::primitive_root_of_unity(root_order).unwrap();
-    let domain_iter = (0..root_order).scan(bfe!(1), |acc, _| {
-        let to_yield = Some(*acc);
-        *acc *= generator;
-        to_yield
-    });
-
-    let domain_shift = domain_iter.clone().map(|d| indeterminate - d).collect();
-    let domain_shift_inverses = XFieldElement::batch_inversion(domain_shift);
-    let domain_over_domain_shift = domain_iter
-        .into_iter()
-        .zip(domain_shift_inverses)
-        .map(|(d, inv)| d * inv);
-    let denominator_inverse = domain_over_domain_shift
-        .clone()
-        .sum::<XFieldElement>()
-        .inverse();
-
-    (domain_over_domain_shift.collect_vec(), denominator_inverse)
-}
-
-pub(crate) fn batch_barycentric_evaluate<
-    FF: FiniteField + Mul<XFieldElement, Output = XFieldElement>,
->(
-    codeword: ArrayView1<FF>,
-    preprocessing_data: &(Vec<XFieldElement>, XFieldElement),
-) -> XFieldElement {
-    let (domain_over_domain_shift, denominator_inverse) = preprocessing_data;
-    let numerator = domain_over_domain_shift
-        .iter()
-        .zip(codeword.iter())
-        .map(|(&dsi, &abscis)| abscis * dsi)
-        .sum::<XFieldElement>();
-    numerator * *denominator_inverse
-}
-
 #[cfg(test)]
 mod tests {
     use std::cmp::max;
diff --git a/triton-vm/src/table/master_table.rs b/triton-vm/src/table/master_table.rs
index 07af78c0..4ee96598 100644
--- a/triton-vm/src/table/master_table.rs
+++ b/triton-vm/src/table/master_table.rs
@@ -93,8 +93,6 @@ use crate::arithmetic_domain::ArithmeticDomain;
 use crate::challenges::Challenges;
 use crate::config::CacheDecision;
 use crate::error::ProvingError;
-use crate::fri::batch_barycentric_evaluate;
-use crate::fri::batch_barycentric_preprocess;
 use crate::ndarray_helper::fast_zeros_column_major;
 use crate::ndarray_helper::horizontal_multi_slice_mut;
 use crate::ndarray_helper::partial_sums;
@@ -319,13 +317,34 @@ where
             XFieldElement::ZERO;
             self.randomized_trace_table().ncols()
         ]);
-        let barycentric_preprocessing_data =
-            batch_barycentric_preprocess(self.randomized_trace_domain().length, indeterminate);
+
+        // The following is a batched version of barycentric Lagrangian evaluation.
+        // Since the method `barycentric_evaluate` is self-contained, not returning
+        // intermediate items necessary for batching, and since returning and reusing
+        // those indermediate items would produce a challenging interface, the relevant
+        // parts are reimplemented here.
+        let domain = self.randomized_trace_domain().domain_values();
+        let domain_shift = domain.iter().map(|&d| indeterminate - d).collect();
+        let domain_shift_inverses = XFieldElement::batch_inversion(domain_shift);
+        let domain_over_domain_shift = domain
+            .into_iter()
+            .zip(domain_shift_inverses)
+            .map(|(d, inv)| d * inv);
+        let denominator_inverse = domain_over_domain_shift
+            .clone()
+            .sum::<XFieldElement>()
+            .inverse();
+
         Zip::from(ood_row.axis_iter_mut(Axis(0)))
             .and(self.randomized_trace_table().axis_iter(Axis(1)))
             .par_for_each(|v, codeword| {
-                let value = batch_barycentric_evaluate(codeword, &barycentric_preprocessing_data);
-                Array0::from_elem((), value).move_into(v);
+                let numerator = domain_over_domain_shift
+                    .clone()
+                    .zip(codeword)
+                    .map(|(dsi, &abscis)| abscis * dsi)
+                    .sum::<XFieldElement>();
+
+                Array0::from_elem((), numerator * denominator_inverse).move_into(v);
             });
         ood_row
     }