diff --git a/src/circuit/circuit_frame.rs b/src/circuit/circuit_frame.rs
index cc7022c3e8..434f35a559 100644
--- a/src/circuit/circuit_frame.rs
+++ b/src/circuit/circuit_frame.rs
@@ -93,27 +93,19 @@ impl<'a, F: LurkField, C: Coprocessor<F>> CircuitFrame<'a, F, C> {
 
 impl<'a, F: LurkField, C: Coprocessor<F>> MultiFrame<'a, F, C> {
     pub fn blank(folding_config: Arc<FoldingConfig<F, C>>, meta: Meta<F>) -> Self {
-        match meta {
-            Meta::Lurk => Self {
-                store: None,
-                input: None,
-                output: None,
-                frames: None,
-                cached_witness: None,
-                count: folding_config.reduction_count(),
-                folding_config,
-                meta,
-            },
-            Meta::Coprocessor(_z_ptr) => Self {
-                store: None,
-                input: None,
-                output: None,
-                frames: None,
-                cached_witness: None,
-                count: 1,
-                folding_config,
-                meta,
-            },
+        let count = match meta {
+            Meta::Lurk => folding_config.reduction_count(),
+            Meta::Coprocessor(_zptr)  => 1
+        };
+        Self {
+            store: None,
+            input: None,
+            output: None,
+            frames: None,
+            cached_witness: None,
+            count,
+            folding_config,
+            meta,
         }
     }
 
@@ -141,9 +133,7 @@ impl<'a, F: LurkField, C: Coprocessor<F>> MultiFrame<'a, F, C> {
 
             for x in chunk {
                 let circuit_frame = CircuitFrame::from_frame(x, store);
-                if meta.is_none() {
-                    meta = Some(x.meta);
-                }
+                meta.get_or_insert(x.meta);
                 inner_frames.push(circuit_frame);
             }
 
@@ -471,6 +461,7 @@ impl<
 type AllocatedIO<F> = (AllocatedPtr<F>, AllocatedPtr<F>, AllocatedContPtr<F>);
 
 impl<F: LurkField, C: Coprocessor<F>> CircuitFrame<'_, F, C> {
+    #[tracing::instrument(skip_all, name = "CircuitFrame::synthesize", level="debug")]
     pub(crate) fn synthesize<CS: ConstraintSystem<F>>(
         &self,
         cs: &mut CS,
@@ -483,7 +474,6 @@ impl<F: LurkField, C: Coprocessor<F>> CircuitFrame<'_, F, C> {
         cont_circuit_witness: Option<ContCircuitWitness<F>>,
     ) -> Result<AllocatedIO<F>, SynthesisError> {
         let (input_expr, input_env, input_cont) = inputs;
-        debug!("synthesizing frame");
         let reduce = |store| {
             let cons_circuit_witness = if let Some(ccw) = cons_circuit_witness {
                 ccw
diff --git a/src/circuit/gadgets/pointer.rs b/src/circuit/gadgets/pointer.rs
index 1a3243476a..d8af659845 100644
--- a/src/circuit/gadgets/pointer.rs
+++ b/src/circuit/gadgets/pointer.rs
@@ -760,7 +760,7 @@ impl<F: LurkField> AllocatedContPtr<F> {
             store.poseidon_constants().c8(),
         )?;
 
-        let cont = AllocatedContPtr {
+        let cont = AllocatedContPtr {   
             tag: cont_tag.clone(),
             hash,
         };
diff --git a/src/proof/nova.rs b/src/proof/nova.rs
index 58cb6afbf1..2d1dce55dc 100644
--- a/src/proof/nova.rs
+++ b/src/proof/nova.rs
@@ -391,7 +391,7 @@ impl<'a, F: LurkField, C: Coprocessor<F>> StepCircuit<F> for MultiFrame<'a, F, C
                     .folding_config
                     .lang()
                     .get_coprocessor_from_zptr(&z_ptr)
-                    .expect("coprocessor missing");
+                    .expect("coprocessor not found for a frame that requires one");
                 match self.frames.as_ref() {
                     Some(frames) => {
                         assert_eq!(1, frames.len());
diff --git a/src/proof/supernova.rs b/src/proof/supernova.rs
index 619ce8eb59..b0cb61d6d6 100644
--- a/src/proof/supernova.rs
+++ b/src/proof/supernova.rs
@@ -46,6 +46,7 @@ where
 {
     pp: SuperNovaPublicParams<F>,
     // SuperNova does not yet have a `CompressedSNARK`.
+    // see https://github.com/lurk-lab/arecibo/issues/27
     // pk: ProverKey<G1<F>, G2<F>, C1<'a, F, C>, C2<F>, SS1<F>, SS2<F>>,
     // vk: VerifierKey<G1<F>, G2<F>, C1<'a, F, C>, C2<F>, SS1<F>, SS2<F>>,
     _p: PhantomData<C>,
@@ -97,9 +98,6 @@ where
     <<G1<F> as Group>::Scalar as PrimeField>::Repr: Abomonation,
     <<G2<F> as Group>::Scalar as PrimeField>::Repr: Abomonation,
     <F as PrimeField>::Repr: Abomonation,
-    C: Coprocessor<F>,
-    F: CurveCycleEquipped + LurkField,
-    <<<F as CurveCycleEquipped>::G2 as Group>::Scalar as PrimeField>::Repr: Abomonation,
 {
     /// Proves the computation recursively, generating a recursive SNARK proof.
     #[tracing::instrument(skip_all, name = "Proof::prove_recursively")]