diff --git a/evm/src/all_stark.rs b/evm/src/all_stark.rs
index cc160e06..a3c78b88 100644
--- a/evm/src/all_stark.rs
+++ b/evm/src/all_stark.rs
@@ -67,11 +67,12 @@ mod tests {
     use crate::all_stark::{AllStark, Table};
     use crate::config::StarkConfig;
     use crate::cpu::columns::{KECCAK_INPUT_LIMBS, KECCAK_OUTPUT_LIMBS};
-    use crate::cpu::cpu_stark::CpuStark;
-    use crate::cross_table_lookup::{Column, CrossTableLookup, TableWithColumns};
-    use crate::keccak::keccak_stark::{KeccakStark, NUM_INPUTS, NUM_ROUNDS};
-    use crate::logic;
-    use crate::logic::LogicStark;
+    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::proof::AllProof;
     use crate::prover::prove;
     use crate::recursive_verifier::{
@@ -228,71 +229,27 @@ mod tests {
             &logic_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 cross_table_lookups = vec![
             CrossTableLookup::new(
                 vec![TableWithColumns::new(
                     Table::Cpu,
-                    Column::singles(cpu_keccak_input_output).collect(),
-                    Some(Column::single(cpu::columns::IS_KECCAK)),
+                    cpu_stark_mod::ctl_data_keccak(),
+                    Some(cpu_stark_mod::ctl_filter_keccak()),
                 )],
                 TableWithColumns::new(
                     Table::Keccak,
-                    keccak_keccak_input_output,
-                    Some(Column::single(keccak::registers::reg_step(NUM_ROUNDS - 1))),
+                    keccak_stark_mod::ctl_data(),
+                    Some(keccak_stark_mod::ctl_filter()),
                 ),
                 None,
             ),
             CrossTableLookup::new(
                 vec![TableWithColumns::new(
                     Table::Cpu,
-                    Column::singles(cpu_logic_input_output).collect(),
-                    Some(Column::sum([
-                        cpu::columns::IS_AND,
-                        cpu::columns::IS_OR,
-                        cpu::columns::IS_XOR,
-                    ])),
+                    cpu_stark_mod::ctl_data_logic(),
+                    Some(cpu_stark_mod::ctl_filter_logic()),
                 )],
-                TableWithColumns::new(
-                    Table::Logic,
-                    Column::singles(logic_logic_input_output).collect(),
-                    Some(Column::sum([
-                        logic::columns::IS_AND,
-                        logic::columns::IS_OR,
-                        logic::columns::IS_XOR,
-                    ])),
-                ),
+                TableWithColumns::new(Table::Logic, logic::ctl_data(), Some(logic::ctl_filter())),
                 None,
             ),
         ];
diff --git a/evm/src/cpu/cpu_stark.rs b/evm/src/cpu/cpu_stark.rs
index 72897bd7..0cb5e2bf 100644
--- a/evm/src/cpu/cpu_stark.rs
+++ b/evm/src/cpu/cpu_stark.rs
@@ -1,15 +1,43 @@
 use std::marker::PhantomData;
 
 use plonky2::field::extension_field::{Extendable, FieldExtension};
+use plonky2::field::field_types::Field;
 use plonky2::field::packed_field::PackedField;
 use plonky2::hash::hash_types::RichField;
 
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 use crate::cpu::{columns, decode, simple_logic};
+use crate::cross_table_lookup::Column;
 use crate::permutation::PermutationPair;
 use crate::stark::Stark;
 use crate::vars::{StarkEvaluationTargets, StarkEvaluationVars};
 
+pub fn ctl_data_keccak<F: Field>() -> Vec<Column<F>> {
+    let mut res: Vec<_> = columns::KECCAK_INPUT_LIMBS.map(Column::single).collect();
+    res.extend(columns::KECCAK_OUTPUT_LIMBS.map(Column::single));
+    res
+}
+
+pub fn ctl_filter_keccak<F: Field>() -> Column<F> {
+    Column::single(columns::IS_KECCAK)
+}
+
+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),
+    ];
+    res.extend(columns::LOGIC_INPUT0.map(Column::single));
+    res.extend(columns::LOGIC_INPUT1.map(Column::single));
+    res.extend(columns::LOGIC_OUTPUT.map(Column::single));
+    res
+}
+
+pub fn ctl_filter_logic<F: Field>() -> Column<F> {
+    Column::sum([columns::IS_AND, columns::IS_OR, columns::IS_XOR])
+}
+
 #[derive(Copy, Clone)]
 pub struct CpuStark<F, const D: usize> {
     pub f: PhantomData<F>,
diff --git a/evm/src/keccak/keccak_stark.rs b/evm/src/keccak/keccak_stark.rs
index dbc650d8..59e9daac 100644
--- a/evm/src/keccak/keccak_stark.rs
+++ b/evm/src/keccak/keccak_stark.rs
@@ -3,6 +3,7 @@ use std::marker::PhantomData;
 use itertools::Itertools;
 use log::info;
 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;
@@ -11,13 +12,14 @@ use plonky2::timed;
 use plonky2::util::timing::TimingTree;
 
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
+use crate::cross_table_lookup::Column;
 use crate::keccak::constants::{rc_value, rc_value_bit};
 use crate::keccak::logic::{
     andn, andn_gen, andn_gen_circuit, xor, xor3_gen, xor3_gen_circuit, xor_gen, xor_gen_circuit,
 };
 use crate::keccak::registers::{
     reg_a, reg_a_prime, reg_a_prime_prime, reg_a_prime_prime_0_0_bit, reg_a_prime_prime_prime,
-    reg_b, reg_c, reg_c_partial, reg_step, NUM_REGISTERS,
+    reg_b, reg_c, reg_c_partial, reg_input_limb, reg_output_limb, reg_step, NUM_REGISTERS,
 };
 use crate::keccak::round_flags::{eval_round_flags, eval_round_flags_recursively};
 use crate::stark::Stark;
@@ -32,6 +34,16 @@ pub(crate) const NUM_INPUTS: usize = 25;
 
 pub(crate) const NUM_PUBLIC_INPUTS: usize = 0;
 
+pub fn ctl_data<F: Field>() -> Vec<Column<F>> {
+    let mut res: Vec<_> = (0..2 * NUM_INPUTS).map(reg_input_limb).collect();
+    res.extend(Column::singles((0..2 * NUM_INPUTS).map(reg_output_limb)));
+    res
+}
+
+pub fn ctl_filter<F: Field>() -> Column<F> {
+    Column::single(reg_step(NUM_ROUNDS - 1))
+}
+
 #[derive(Copy, Clone)]
 pub struct KeccakStark<F, const D: usize> {
     pub(crate) f: PhantomData<F>,
diff --git a/evm/src/logic.rs b/evm/src/logic.rs
index e1cb8aa0..52836c41 100644
--- a/evm/src/logic.rs
+++ b/evm/src/logic.rs
@@ -2,10 +2,12 @@ use std::marker::PhantomData;
 
 use itertools::izip;
 use plonky2::field::extension_field::{Extendable, FieldExtension};
+use plonky2::field::field_types::Field;
 use plonky2::field::packed_field::PackedField;
 use plonky2::hash::hash_types::RichField;
 
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
+use crate::cross_table_lookup::Column;
 use crate::stark::Stark;
 use crate::vars::{StarkEvaluationTargets, StarkEvaluationVars};
 
@@ -42,6 +44,22 @@ pub(crate) mod columns {
     pub const NUM_COLUMNS: usize = INPUT1_BITS.end;
 }
 
+pub fn ctl_data<F: Field>() -> Vec<Column<F>> {
+    let mut res = vec![
+        Column::single(columns::IS_AND),
+        Column::single(columns::IS_OR),
+        Column::single(columns::IS_XOR),
+    ];
+    res.extend(columns::INPUT0_PACKED.map(Column::single));
+    res.extend(columns::INPUT1_PACKED.map(Column::single));
+    res.extend(columns::RESULT.map(Column::single));
+    res
+}
+
+pub fn ctl_filter<F: Field>() -> Column<F> {
+    Column::sum([columns::IS_AND, columns::IS_OR, columns::IS_XOR])
+}
+
 #[derive(Copy, Clone)]
 pub struct LogicStark<F, const D: usize> {
     pub f: PhantomData<F>,