diff --git a/evm/src/all_stark.rs b/evm/src/all_stark.rs
index ba6ae397..0a8aee50 100644
--- a/evm/src/all_stark.rs
+++ b/evm/src/all_stark.rs
@@ -71,14 +71,16 @@ mod tests {
 
     use crate::all_stark::{AllStark, Table};
     use crate::config::StarkConfig;
+    use crate::cpu::columns::{KECCAK_INPUT_LIMBS, KECCAK_OUTPUT_LIMBS, NUM_MEMORY_OPS};
     use crate::cpu::cpu_stark::{self as cpu_stark_mod, CpuStark};
+    use crate::cross_table_lookup::{CrossTableLookup, TableWithColumns};
     use crate::keccak::keccak_stark::{
         self as keccak_stark_mod, KeccakStark, NUM_INPUTS, NUM_ROUNDS,
     };
     use crate::logic::{self, LogicStark};
-    use crate::cpu::columns::{KECCAK_INPUT_LIMBS, KECCAK_OUTPUT_LIMBS, NUM_MEMORY_OPS};
-    use crate::cross_table_lookup::{Column, CrossTableLookup, TableWithColumns};
-    use crate::memory::memory_stark::{generate_random_memory_ops, MemoryStark};
+    use crate::memory::memory_stark::{
+        self as memory_stark_mod, generate_random_memory_ops, MemoryStark,
+    };
     use crate::proof::AllProof;
     use crate::prover::prove;
     use crate::recursive_verifier::{
@@ -283,63 +285,6 @@ mod tests {
             &mut memory_trace,
         );
 
-        let mut cpu_keccak_input_output = cpu::columns::KECCAK_INPUT_LIMBS.collect::<Vec<_>>();
-        cpu_keccak_input_output.extend(cpu::columns::KECCAK_OUTPUT_LIMBS);
-        let mut keccak_keccak_input_output = (0..2 * NUM_INPUTS)
-            .map(keccak::registers::reg_input_limb)
-            .collect::<Vec<_>>();
-        keccak_keccak_input_output.extend(Column::singles(
-            (0..2 * NUM_INPUTS).map(keccak::registers::reg_output_limb),
-        ));
-
-        let cpu_logic_input_output = {
-            let mut res = vec![
-                cpu::columns::IS_AND,
-                cpu::columns::IS_OR,
-                cpu::columns::IS_XOR,
-            ];
-            res.extend(cpu::columns::LOGIC_INPUT0);
-            res.extend(cpu::columns::LOGIC_INPUT1);
-            res.extend(cpu::columns::LOGIC_OUTPUT);
-            res
-        };
-        let logic_logic_input_output = {
-            let mut res = vec![
-                logic::columns::IS_AND,
-                logic::columns::IS_OR,
-                logic::columns::IS_XOR,
-            ];
-            res.extend(logic::columns::INPUT0_PACKED);
-            res.extend(logic::columns::INPUT1_PACKED);
-            res.extend(logic::columns::RESULT);
-            res
-        };
-
-        let cpu_memory_cols: Vec<Vec<_>> = (0..NUM_MEMORY_OPS)
-            .map(|op| {
-                let mut cols: Vec<Column<F>> = Column::singles([
-                    cpu::columns::CLOCK,
-                    cpu::columns::memop_is_read(op),
-                    cpu::columns::memop_addr_context(op),
-                    cpu::columns::memop_addr_segment(op),
-                    cpu::columns::memop_addr_virtual(op),
-                ])
-                .collect_vec();
-                cols.extend(Column::singles(
-                    (0..8).map(|j| cpu::columns::memop_value(op, j)),
-                ));
-                cols
-            })
-            .collect();
-        let mut memory_memory_cols = vec![
-            memory::registers::TIMESTAMP,
-            memory::registers::IS_READ,
-            memory::registers::ADDR_CONTEXT,
-            memory::registers::ADDR_SEGMENT,
-            memory::registers::ADDR_VIRTUAL,
-        ];
-        memory_memory_cols.extend((0..8).map(memory::registers::value_limb));
-
         let mut cross_table_lookups = vec![
             CrossTableLookup::new(
                 vec![TableWithColumns::new(
@@ -364,17 +309,17 @@ mod tests {
                 None,
             ),
         ];
-        cross_table_lookups.extend((0..1).map(|op| {
+        cross_table_lookups.extend((0..NUM_MEMORY_OPS).map(|op| {
             CrossTableLookup::new(
                 vec![TableWithColumns::new(
                     Table::Cpu,
-                    cpu_memory_cols[op].clone(),
-                    Some(Column::single(cpu::columns::uses_memop(op))),
+                    cpu_stark_mod::ctl_data_memory(op),
+                    Some(cpu_stark_mod::ctl_filter_memory(op)),
                 )],
                 TableWithColumns::new(
                     Table::Memory,
-                    Column::singles(memory_memory_cols.clone()).collect(),
-                    Some(Column::single(memory::registers::is_memop(op))),
+                    memory_stark_mod::ctl_data(),
+                    Some(memory_stark_mod::ctl_filter(op)),
                 ),
                 None,
             )
diff --git a/evm/src/cpu/cpu_stark.rs b/evm/src/cpu/cpu_stark.rs
index 0cb5e2bf..4b4d47d9 100644
--- a/evm/src/cpu/cpu_stark.rs
+++ b/evm/src/cpu/cpu_stark.rs
@@ -1,5 +1,6 @@
 use std::marker::PhantomData;
 
+use itertools::Itertools;
 use plonky2::field::extension_field::{Extendable, FieldExtension};
 use plonky2::field::field_types::Field;
 use plonky2::field::packed_field::PackedField;
@@ -23,11 +24,7 @@ pub fn ctl_filter_keccak<F: Field>() -> Column<F> {
 }
 
 pub fn ctl_data_logic<F: Field>() -> Vec<Column<F>> {
-    let mut res = vec![
-        Column::single(columns::IS_AND),
-        Column::single(columns::IS_OR),
-        Column::single(columns::IS_XOR),
-    ];
+    let mut res = Column::singles([columns::IS_AND, columns::IS_OR, columns::IS_XOR]).collect_vec();
     res.extend(columns::LOGIC_INPUT0.map(Column::single));
     res.extend(columns::LOGIC_INPUT1.map(Column::single));
     res.extend(columns::LOGIC_OUTPUT.map(Column::single));
@@ -38,6 +35,23 @@ pub fn ctl_filter_logic<F: Field>() -> Column<F> {
     Column::sum([columns::IS_AND, columns::IS_OR, columns::IS_XOR])
 }
 
+pub fn ctl_data_memory<F: Field>(op: usize) -> Vec<Column<F>> {
+    let mut cols: Vec<Column<F>> = Column::singles([
+        columns::CLOCK,
+        columns::memop_is_read(op),
+        columns::memop_addr_context(op),
+        columns::memop_addr_segment(op),
+        columns::memop_addr_virtual(op),
+    ])
+    .collect_vec();
+    cols.extend(Column::singles((0..8).map(|j| columns::memop_value(op, j))));
+    cols
+}
+
+pub fn ctl_filter_memory<F: Field>(op: usize) -> Column<F> {
+    Column::single(columns::uses_memop(op))
+}
+
 #[derive(Copy, Clone)]
 pub struct CpuStark<F, const D: usize> {
     pub f: PhantomData<F>,
diff --git a/evm/src/memory/memory_stark.rs b/evm/src/memory/memory_stark.rs
index 2b5c54b1..db0a2b12 100644
--- a/evm/src/memory/memory_stark.rs
+++ b/evm/src/memory/memory_stark.rs
@@ -3,6 +3,7 @@ use std::marker::PhantomData;
 
 use itertools::{izip, multiunzip, Itertools};
 use plonky2::field::extension_field::{Extendable, FieldExtension};
+use plonky2::field::field_types::Field;
 use plonky2::field::packed_field::PackedField;
 use plonky2::field::polynomial::PolynomialValues;
 use plonky2::hash::hash_types::RichField;
@@ -12,6 +13,7 @@ use rand::Rng;
 
 use super::registers::is_memop;
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
+use crate::cross_table_lookup::Column;
 use crate::lookup::{eval_lookups, eval_lookups_circuit, permuted_cols};
 use crate::memory::registers::{
     sorted_value_limb, value_limb, ADDR_CONTEXT, ADDR_SEGMENT, ADDR_VIRTUAL, CONTEXT_FIRST_CHANGE,
@@ -26,6 +28,17 @@ use crate::vars::{StarkEvaluationTargets, StarkEvaluationVars};
 
 pub(crate) const NUM_PUBLIC_INPUTS: usize = 0;
 
+pub fn ctl_data<F: Field>() -> Vec<Column<F>> {
+    let mut res = Column::singles([TIMESTAMP, IS_READ, ADDR_CONTEXT, ADDR_SEGMENT, ADDR_VIRTUAL])
+        .collect_vec();
+    res.extend(Column::singles((0..8).map(value_limb)));
+    res
+}
+
+pub fn ctl_filter<F: Field>(op: usize) -> Column<F> {
+    Column::single(is_memop(op))
+}
+
 #[derive(Copy, Clone)]
 pub struct MemoryStark<F, const D: usize> {
     pub(crate) f: PhantomData<F>,