diff --git a/src/gates/comparison.rs b/src/gates/comparison.rs
index 4f6186da..dbd2f941 100644
--- a/src/gates/comparison.rs
+++ b/src/gates/comparison.rs
@@ -16,16 +16,14 @@ use crate::util::{bits_u64, ceil_div_usize};
 /// A gate for checking that one value is smaller than another.
 #[derive(Clone, Debug)]
 pub(crate) struct ComparisonGate<F: PrimeField + Extendable<D>, const D: usize> {
-    pub(crate) num_copies: usize,
     pub(crate) num_bits: usize,
     pub(crate) num_chunks: usize,
     _phantom: PhantomData<F>,
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> ComparisonGate<F, D> {
-    pub fn new(num_copies: usize, num_bits: usize, num_chunks: usize) -> Self {
+    pub fn new(num_bits: usize, num_chunks: usize) -> Self {
         Self {
-            num_copies,
             num_bits,
             num_chunks,
             _phantom: PhantomData,
@@ -36,62 +34,41 @@ impl<F: RichField + Extendable<D>, const D: usize> ComparisonGate<F, D> {
         ceil_div_usize(self.num_bits, self.num_chunks)
     }
 
-    pub fn new_from_config(config: CircuitConfig, num_bits: usize, num_chunks: usize) -> Self {
-        let num_copies = Self::max_num_copies(config.num_routed_wires, num_bits, num_chunks);
-        Self::new(num_copies, num_bits, num_chunks)
+    pub fn wire_first_input(&self) -> usize {
+        0
     }
 
-    pub fn max_num_copies(num_routed_wires: usize, num_bits: usize, num_chunks: usize) -> usize {
-        let chunk_bits = ceil_div_usize(num_bits, num_chunks);
-        let wires_per_copy = 4 + chunk_bits + 4 * num_chunks;
-        num_routed_wires / wires_per_copy
+    pub fn wire_second_input(&self) -> usize {
+        1
     }
 
-    pub fn wires_per_copy(&self) -> usize {
-        4 + self.chunk_bits() + 4 * self.num_chunks
+    pub fn wire_z_val(&self) -> usize {
+        2
     }
 
-    pub fn wire_first_input(&self, copy: usize) -> usize {
-        debug_assert!(copy < self.num_copies);
-        copy * self.wires_per_copy()
-    }
-
-    pub fn wire_second_input(&self, copy: usize) -> usize {
-        debug_assert!(copy < self.num_copies);
-        copy * self.wires_per_copy() + 1
-    }
-
-    pub fn wire_z_val(&self, copy: usize) -> usize {
-        copy * self.wires_per_copy() + 2
-    }
-
-    pub fn wire_z_bit(&self, copy: usize, bit_index: usize) -> usize {
+    pub fn wire_z_bit(&self, bit_index: usize) -> usize {
         debug_assert!(bit_index < self.chunk_bits() + 1);
-        copy * self.wires_per_copy() + 3 + bit_index
+        3 + bit_index
     }
 
-    pub fn wire_first_chunk_val(&self, copy: usize, chunk: usize) -> usize {
-        debug_assert!(copy < self.num_copies);
+    pub fn wire_first_chunk_val(&self, chunk: usize) -> usize {
         debug_assert!(chunk < self.num_chunks);
-        copy * self.wires_per_copy() + 4 + self.chunk_bits() + chunk
+        4 + self.chunk_bits() + chunk
     }
 
-    pub fn wire_second_chunk_val(&self, copy: usize, chunk: usize) -> usize {
-        debug_assert!(copy < self.num_copies);
+    pub fn wire_second_chunk_val(&self, chunk: usize) -> usize {
         debug_assert!(chunk < self.num_chunks);
-        copy * self.wires_per_copy() + 4 + self.chunk_bits() + self.num_chunks + chunk
+        4 + self.chunk_bits() + self.num_chunks + chunk
     }
 
-    pub fn wire_equality_dummy(&self, copy: usize, chunk: usize) -> usize {
-        debug_assert!(copy < self.num_copies);
+    pub fn wire_equality_dummy(&self, chunk: usize) -> usize {
         debug_assert!(chunk < self.num_chunks);
-        copy * self.wires_per_copy() + 4 + self.chunk_bits() + 2 * self.num_chunks + chunk
+        4 + self.chunk_bits() + 2 * self.num_chunks + chunk
     }
 
-    pub fn wire_chunks_equal(&self, copy: usize, chunk: usize) -> usize {
-        debug_assert!(copy < self.num_copies);
+    pub fn wire_chunks_equal(&self, chunk: usize) -> usize {
         debug_assert!(chunk < self.num_chunks);
-        copy * self.wires_per_copy() + 4 + self.chunk_bits() + 3 * self.num_chunks + chunk
+        4 + self.chunk_bits() + 3 * self.num_chunks + chunk
     }
 }
 
@@ -103,72 +80,70 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
     fn eval_unfiltered(&self, vars: EvaluationVars<F, D>) -> Vec<F::Extension> {
         let mut constraints = Vec::with_capacity(self.num_constraints());
 
-        for c in 0..self.num_copies {
-            let first_input = vars.local_wires[self.wire_first_input(c)];
-            let second_input = vars.local_wires[self.wire_second_input(c)];
+        let first_input = vars.local_wires[self.wire_first_input()];
+        let second_input = vars.local_wires[self.wire_second_input()];
 
-            // Get chunks and assert that they match
-            let first_chunks: Vec<F::Extension> = (0..self.num_chunks)
-                .map(|i| vars.local_wires[self.wire_first_chunk_val(c, i)])
-                .collect();
-            let second_chunks: Vec<F::Extension> = (0..self.num_chunks)
-                .map(|i| vars.local_wires[self.wire_second_chunk_val(c, i)])
-                .collect();
+        // Get chunks and assert that they match
+        let first_chunks: Vec<F::Extension> = (0..self.num_chunks)
+            .map(|i| vars.local_wires[self.wire_first_chunk_val(i)])
+            .collect();
+        let second_chunks: Vec<F::Extension> = (0..self.num_chunks)
+            .map(|i| vars.local_wires[self.wire_second_chunk_val(i)])
+            .collect();
 
-            let chunk_base_powers: Vec<F::Extension> = (0..self.num_chunks)
-                .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64))
-                .collect();
+        let chunk_base_powers: Vec<F::Extension> = (0..self.num_chunks)
+            .map(|i| F::Extension::TWO.exp_u64((i * self.chunk_bits()) as u64))
+            .collect();
 
-            let first_chunks_combined = first_chunks
-                .iter()
-                .zip(chunk_base_powers.iter())
-                .map(|(b, x)| *b * *x)
-                .fold(F::Extension::ZERO, |a, b| a + b);
-            let second_chunks_combined = second_chunks
-                .iter()
-                .zip(chunk_base_powers.iter())
-                .map(|(b, x)| *b * *x)
-                .fold(F::Extension::ZERO, |a, b| a + b);
+        let first_chunks_combined = first_chunks
+            .iter()
+            .zip(chunk_base_powers.iter())
+            .map(|(b, x)| *b * *x)
+            .fold(F::Extension::ZERO, |a, b| a + b);
+        let second_chunks_combined = second_chunks
+            .iter()
+            .zip(chunk_base_powers.iter())
+            .map(|(b, x)| *b * *x)
+            .fold(F::Extension::ZERO, |a, b| a + b);
 
-            constraints.push(first_chunks_combined - first_input);
-            constraints.push(second_chunks_combined - second_input);
+        constraints.push(first_chunks_combined - first_input);
+        constraints.push(second_chunks_combined - second_input);
 
-            let mut most_significant_diff = F::Extension::ZERO;
+        let mut most_significant_diff = F::Extension::ZERO;
 
-            // Find the chosen chunk.
-            for i in 0..self.num_chunks {
-                let difference = first_chunks[i] - second_chunks[i];
-                let equality_dummy = vars.local_wires[self.wire_equality_dummy(c, i)];
-                let chunks_equal = vars.local_wires[self.wire_chunks_equal(c, i)];
+        // Find the chosen chunk.
+        for i in 0..self.num_chunks {
+            let difference = first_chunks[i] - second_chunks[i];
+            let equality_dummy = vars.local_wires[self.wire_equality_dummy(i)];
+            let chunks_equal = vars.local_wires[self.wire_chunks_equal(i)];
 
-                // Two constraints identifying index.
-                constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal));
-                constraints.push(chunks_equal * difference);
+            // Two constraints identifying index.
+            constraints.push(difference * equality_dummy - (F::Extension::ONE - chunks_equal));
+            constraints.push(chunks_equal * difference);
 
-                let this_diff = first_chunks[i] - second_chunks[i];
-                most_significant_diff = chunks_equal * most_significant_diff
-                    + (F::Extension::ONE - chunks_equal) * this_diff;
-            }
-
-            let z_bits: Vec<F::Extension> = (0..self.chunk_bits() + 1)
-                .map(|i| vars.local_wires[self.wire_z_bit(c, i)])
-                .collect();
-
-            let powers_of_two: Vec<F::Extension> = (0..self.chunk_bits() + 1)
-                .map(|i| F::Extension::TWO.exp_u64(i as u64))
-                .collect();
-            let z_bits_combined = z_bits
-                .iter()
-                .zip(powers_of_two.iter())
-                .map(|(b, x)| *b * *x)
-                .fold(F::Extension::ZERO, |a, b| a + b);
-
-            let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64);
-            constraints.push(z_bits_combined - (two_n + most_significant_diff));
-
-            //constraints.push(z_bits[self.chunk_bits() - 1]);
+            let this_diff = first_chunks[i] - second_chunks[i];
+            most_significant_diff = chunks_equal * most_significant_diff
+                + (F::Extension::ONE - chunks_equal) * this_diff;
         }
 
+        let z_bits: Vec<F::Extension> = (0..self.chunk_bits() + 1)
+            .map(|i| vars.local_wires[self.wire_z_bit(i)])
+            .collect();
+
+        let powers_of_two: Vec<F::Extension> = (0..self.chunk_bits() + 1)
+            .map(|i| F::Extension::TWO.exp_u64(i as u64))
+            .collect();
+        let z_bits_combined = z_bits
+            .iter()
+            .zip(powers_of_two.iter())
+            .map(|(b, x)| *b * *x)
+            .fold(F::Extension::ZERO, |a, b| a + b);
+
+        let two_n = F::Extension::TWO.exp_u64(self.chunk_bits() as u64);
+        constraints.push(z_bits_combined - (two_n + most_significant_diff));
+
+        //constraints.push(z_bits[self.chunk_bits() - 1]);
+
         constraints
     }
 
@@ -189,21 +164,15 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
         gate_index: usize,
         _local_constants: &[F],
     ) -> Vec<Box<dyn WitnessGenerator<F>>> {
-        (0..self.num_copies)
-            .map(|c| {
-                let gen = ComparisonGenerator::<F, D> {
-                    gate_index,
-                    gate: self.clone(),
-                    copy: c,
-                };
-                let g: Box<dyn WitnessGenerator<F>> = Box::new(gen.adapter());
-                g
-            })
-            .collect()
+        let gen = ComparisonGenerator::<F, D> {
+            gate_index,
+            gate: self.clone(),
+        };
+        vec![Box::new(gen.adapter())]
     }
 
     fn num_wires(&self) -> usize {
-        self.wire_chunks_equal(self.num_copies - 1, self.num_chunks - 1) + 1
+        self.wire_chunks_equal(self.num_chunks - 1) + 1
     }
 
     fn num_constants(&self) -> usize {
@@ -215,7 +184,7 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
     }
 
     fn num_constraints(&self) -> usize {
-        self.num_copies * (4 + 2 * self.num_chunks)
+        4 + 2 * self.num_chunks
     }
 }
 
@@ -223,7 +192,6 @@ impl<F: RichField + Extendable<D>, const D: usize> Gate<F, D> for ComparisonGate
 struct ComparisonGenerator<F: RichField + Extendable<D>, const D: usize> {
     gate_index: usize,
     gate: ComparisonGate<F, D>,
-    copy: usize,
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
@@ -233,8 +201,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
         let local_target = |input| Target::wire(self.gate_index, input);
 
         let mut deps = Vec::new();
-        deps.push(local_target(self.gate.wire_first_input(self.copy)));
-        deps.push(local_target(self.gate.wire_second_input(self.copy)));
+        deps.push(local_target(self.gate.wire_first_input()));
+        deps.push(local_target(self.gate.wire_second_input()));
         deps
     }
 
@@ -246,8 +214,8 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
 
         let get_local_wire = |input| witness.get_wire(local_wire(input));
 
-        let first_input = get_local_wire(self.gate.wire_first_input(self.copy));
-        let second_input = get_local_wire(self.gate.wire_second_input(self.copy));
+        let first_input = get_local_wire(self.gate.wire_first_input());
+        let second_input = get_local_wire(self.gate.wire_second_input());
 
         let first_input_u64 = first_input.to_canonical_u64();
         let second_input_u64 = second_input.to_canonical_u64();
@@ -316,25 +284,22 @@ impl<F: RichField + Extendable<D>, const D: usize> SimpleGenerator<F>
             })
             .collect();
 
-        out_buffer.set_wire(local_wire(self.gate.wire_z_val(self.copy)), z);
+        out_buffer.set_wire(local_wire(self.gate.wire_z_val()), z);
         for b in 0..self.gate.chunk_bits() + 1 {
-            out_buffer.set_wire(local_wire(self.gate.wire_z_bit(self.copy, b)), z_bits[b]);
+            out_buffer.set_wire(local_wire(self.gate.wire_z_bit(b)), z_bits[b]);
         }
         for i in 0..self.gate.num_chunks {
             out_buffer.set_wire(
-                local_wire(self.gate.wire_first_chunk_val(self.copy, i)),
+                local_wire(self.gate.wire_first_chunk_val(i)),
                 first_input_chunks[i],
             );
             out_buffer.set_wire(
-                local_wire(self.gate.wire_second_chunk_val(self.copy, i)),
+                local_wire(self.gate.wire_second_chunk_val(i)),
                 second_input_chunks[i],
             );
+            out_buffer.set_wire(local_wire(self.gate.wire_chunks_equal(i)), chunks_equal[i]);
             out_buffer.set_wire(
-                local_wire(self.gate.wire_chunks_equal(self.copy, i)),
-                chunks_equal[i],
-            );
-            out_buffer.set_wire(
-                local_wire(self.gate.wire_equality_dummy(self.copy, i)),
+                local_wire(self.gate.wire_equality_dummy(i)),
                 equality_dummies[i],
             );
         }
@@ -362,33 +327,27 @@ mod tests {
     fn wire_indices() {
         type CG = ComparisonGate<CrandallField, 4>;
         let num_bits = 40;
-        let num_copies = 3;
         let num_chunks = 5;
 
         let gate = CG {
             num_bits,
             num_chunks,
-            num_copies,
             _phantom: PhantomData,
         };
 
-        assert_eq!(gate.wire_first_input(0), 0);
-        assert_eq!(gate.wire_second_input(0), 1);
-        assert_eq!(gate.wire_z_val(0), 2);
-        assert_eq!(gate.wire_z_bit(0, 0), 3);
-        assert_eq!(gate.wire_z_bit(0, 8), 11);
-        assert_eq!(gate.wire_first_chunk_val(0, 0), 12);
-        assert_eq!(gate.wire_first_chunk_val(0, 4), 16);
-        assert_eq!(gate.wire_second_chunk_val(0, 0), 17);
-        assert_eq!(gate.wire_second_chunk_val(0, 4), 21);
-        assert_eq!(gate.wire_equality_dummy(0, 0), 22);
-        assert_eq!(gate.wire_equality_dummy(0, 4), 26);
-        assert_eq!(gate.wire_chunks_equal(0, 0), 27);
-        assert_eq!(gate.wire_chunks_equal(0, 4), 31);
-        assert_eq!(gate.wire_first_input(1), 32);
-        assert_eq!(gate.wire_chunks_equal(1, 4), 63);
-        assert_eq!(gate.wire_first_input(2), 64);
-        assert_eq!(gate.wire_chunks_equal(2, 4), 95);
+        assert_eq!(gate.wire_first_input(), 0);
+        assert_eq!(gate.wire_second_input(), 1);
+        assert_eq!(gate.wire_z_val(), 2);
+        assert_eq!(gate.wire_z_bit(0), 3);
+        assert_eq!(gate.wire_z_bit(8), 11);
+        assert_eq!(gate.wire_first_chunk_val(0), 12);
+        assert_eq!(gate.wire_first_chunk_val(4), 16);
+        assert_eq!(gate.wire_second_chunk_val(0), 17);
+        assert_eq!(gate.wire_second_chunk_val(4), 21);
+        assert_eq!(gate.wire_equality_dummy(0), 22);
+        assert_eq!(gate.wire_equality_dummy(4), 26);
+        assert_eq!(gate.wire_chunks_equal(0), 27);
+        assert_eq!(gate.wire_chunks_equal(4), 31);
     }
 
     #[test]
@@ -396,11 +355,7 @@ mod tests {
         let num_bits = 40;
         let num_chunks = 5;
 
-        test_low_degree::<CrandallField, _, 4>(ComparisonGate::<_, 4>::new_from_config(
-            CircuitConfig::large_config(),
-            num_bits,
-            num_chunks,
-        ))
+        test_low_degree::<CrandallField, _, 4>(ComparisonGate::<_, 4>::new(num_bits, num_chunks))
     }
 
     #[test]
@@ -408,11 +363,7 @@ mod tests {
         let num_bits = 40;
         let num_chunks = 5;
 
-        test_eval_fns::<CrandallField, _, 4>(ComparisonGate::<_, 4>::new_from_config(
-            CircuitConfig::large_config(),
-            num_bits,
-            num_chunks,
-        ))
+        test_eval_fns::<CrandallField, _, 4>(ComparisonGate::<_, 4>::new(num_bits, num_chunks))
     }
 
     #[test]
@@ -524,7 +475,6 @@ mod tests {
             .collect();
 
         let gate = ComparisonGate::<F, D> {
-            num_copies,
             num_bits,
             num_chunks,
             _phantom: PhantomData,